X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Fbuilder%2Fimpl%2FUsesNodeBuilderImpl.java;h=77a465d5fd3346ab41657c84421f5cd35c1c6e98;hb=3c8c7171aa9a2fdf322b85cf104ae551665aa0d8;hp=3e7beda7565cb41df80c895b135fc9d81255a968;hpb=8992ae54ecd2c79e0d93d0904962c5f32f3bb33a;p=controller.git

diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/builder/impl/UsesNodeBuilderImpl.java b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/builder/impl/UsesNodeBuilderImpl.java
index 3e7beda756..77a465d5fd 100644
--- a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/builder/impl/UsesNodeBuilderImpl.java
+++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/builder/impl/UsesNodeBuilderImpl.java
@@ -15,48 +15,80 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import org.opendaylight.controller.yang.common.QName;
 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
 import org.opendaylight.controller.yang.model.api.SchemaNode;
 import org.opendaylight.controller.yang.model.api.SchemaPath;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.controller.yang.model.api.UsesNode;
 import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.controller.yang.parser.builder.api.Builder;
+import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;
 import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
 import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
 import org.opendaylight.controller.yang.parser.util.RefineHolder;
 
-final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
-    private final UsesNodeImpl instance;
+public final class UsesNodeBuilderImpl implements UsesNodeBuilder {
+    private boolean isBuilt;
+    private UsesNodeImpl instance;
     private final int line;
-    private final SchemaPath groupingPath;
+    private final DataNodeContainerBuilder parent;
+    private final String groupingName;
+    private SchemaPath groupingPath;
+    private boolean augmenting;
+    private boolean addedByUses;
     private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();
-    private List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();
-    private List<RefineHolder> refines = new ArrayList<RefineHolder>();
+    private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();
+    private final List<RefineHolder> refines = new ArrayList<RefineHolder>();
+    private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
 
-    UsesNodeBuilderImpl(final String groupingPathStr, final int line) {
-        this.groupingPath = parseUsesPath(groupingPathStr);
+    public UsesNodeBuilderImpl(final String groupingName, final int line, final DataNodeContainerBuilder parent) {
+        this.groupingName = groupingName;
         this.line = line;
-        instance = new UsesNodeImpl(groupingPath);
+        this.parent = parent;
+    }
+
+    public UsesNodeBuilderImpl(UsesNodeBuilder b) {
+        groupingName = b.getGroupingName();
+        line = b.getLine();
+        parent = b.getParent();
+        groupingPath = b.getGroupingPath();
+        augmenting = b.isAugmenting();
+        addedByUses = b.isAddedByUses();
+        addedAugments.addAll(b.getAugmentations());
+        refineBuilders.addAll(b.getRefineNodes());
+        refines.addAll(b.getRefines());
     }
 
     @Override
     public UsesNode build() {
-        // AUGMENTATIONS
-        final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();
-        for (AugmentationSchemaBuilder builder : addedAugments) {
-            augments.add(builder.build());
-        }
-        instance.setAugmentations(augments);
+        if (!isBuilt) {
+            instance = new UsesNodeImpl(groupingPath);
+            instance.setAugmenting(augmenting);
+            instance.setAddedByUses(addedByUses);
 
-        // REFINES
-        final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();
-        for (SchemaNodeBuilder refineBuilder : refineBuilders) {
-            SchemaNode refineNode = refineBuilder.build();
-            refineNodes.put(refineNode.getPath(), refineNode);
-        }
-        instance.setRefines(refineNodes);
+            // AUGMENTATIONS
+            final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();
+            for (AugmentationSchemaBuilder builder : addedAugments) {
+                augments.add(builder.build());
+            }
+            instance.setAugmentations(augments);
+
+            // REFINES
+            final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();
+            for (SchemaNodeBuilder refineBuilder : refineBuilders) {
+                SchemaNode refineNode = refineBuilder.build();
+                refineNodes.put(refineNode.getPath(), refineNode);
+            }
+            instance.setRefines(refineNodes);
 
+            // UNKNOWN NODES
+            List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+            for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+                unknownNodes.add(b.build());
+            }
+            instance.setUnknownSchemaNodes(unknownNodes);
+
+            isBuilt = true;
+        }
         return instance;
     }
 
@@ -65,19 +97,59 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
         return line;
     }
 
+    @Override
+    public DataNodeContainerBuilder getParent() {
+        return parent;
+    }
+
     @Override
     public SchemaPath getGroupingPath() {
         return groupingPath;
     }
 
+    @Override
+    public void setGroupingPath(SchemaPath groupingPath) {
+        this.groupingPath = groupingPath;
+    }
+
+    @Override
+    public String getGroupingName() {
+        return groupingName;
+    }
+
+    @Override
+    public Set<AugmentationSchemaBuilder> getAugmentations() {
+        return addedAugments;
+    }
+
     @Override
     public void addAugment(final AugmentationSchemaBuilder augmentBuilder) {
         addedAugments.add(augmentBuilder);
     }
 
+    @Override
+    public boolean isAugmenting() {
+        return augmenting;
+    }
+
     @Override
     public void setAugmenting(final boolean augmenting) {
-        instance.setAugmenting(augmenting);
+        this.augmenting = augmenting;
+    }
+
+    @Override
+    public boolean isAddedByUses() {
+        return addedByUses;
+    }
+
+    @Override
+    public void setAddedByUses(final boolean addedByUses) {
+        this.addedByUses = addedByUses;
+    }
+
+    @Override
+    public List<SchemaNodeBuilder> getRefineNodes() {
+        return refineBuilders;
     }
 
     @Override
@@ -95,29 +167,22 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
         refines.add(refine);
     }
 
-    private SchemaPath parseUsesPath(final String groupingPathStr) {
-        final String[] splittedPath = groupingPathStr.split("/");
-        final List<QName> path = new ArrayList<QName>();
-        QName name;
-        for (String pathElement : splittedPath) {
-            final String[] splittedElement = pathElement.split(":");
-            if (splittedElement.length == 1) {
-                name = new QName(null, null, null, splittedElement[0]);
-            } else {
-                name = new QName(null, null, splittedElement[0],
-                        splittedElement[1]);
-            }
-            path.add(name);
-        }
-        final boolean absolute = groupingPathStr.startsWith("/");
-        return new SchemaPath(path, absolute);
+    public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+        return addedUnknownNodes;
+    }
+
+    @Override
+    public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
+        addedUnknownNodes.add(unknownNode);
     }
 
-    private final class UsesNodeImpl implements UsesNode {
+    public final class UsesNodeImpl implements UsesNode {
         private final SchemaPath groupingPath;
         private Set<AugmentationSchema> augmentations = Collections.emptySet();
         private boolean augmenting;
+        private boolean addedByUses;
         private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();
+        private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 
         private UsesNodeImpl(final SchemaPath groupingPath) {
             this.groupingPath = groupingPath;
@@ -133,8 +198,7 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
             return augmentations;
         }
 
-        private void setAugmentations(
-                final Set<AugmentationSchema> augmentations) {
+        private void setAugmentations(final Set<AugmentationSchema> augmentations) {
             if (augmentations != null) {
                 this.augmentations = augmentations;
             }
@@ -149,6 +213,15 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
             this.augmenting = augmenting;
         }
 
+        @Override
+        public boolean isAddedByUses() {
+            return addedByUses;
+        }
+
+        private void setAddedByUses(final boolean addedByUses) {
+            this.addedByUses = addedByUses;
+        }
+
         @Override
         public Map<SchemaPath, SchemaNode> getRefines() {
             return refines;
@@ -160,14 +233,26 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
             }
         }
 
+        public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+            return unknownNodes;
+        }
+
+        private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+            if (unknownSchemaNodes != null) {
+                this.unknownNodes = unknownSchemaNodes;
+            }
+        }
+
+        public UsesNodeBuilder toBuilder() {
+            return UsesNodeBuilderImpl.this;
+        }
+
         @Override
         public int hashCode() {
             final int prime = 31;
             int result = 1;
-            result = prime * result
-                    + ((groupingPath == null) ? 0 : groupingPath.hashCode());
-            result = prime * result
-                    + ((augmentations == null) ? 0 : augmentations.hashCode());
+            result = prime * result + ((groupingPath == null) ? 0 : groupingPath.hashCode());
+            result = prime * result + ((augmentations == null) ? 0 : augmentations.hashCode());
             result = prime * result + (augmenting ? 1231 : 1237);
             return result;
         }
@@ -206,8 +291,7 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {
 
         @Override
         public String toString() {
-            StringBuilder sb = new StringBuilder(
-                    UsesNodeImpl.class.getSimpleName());
+            StringBuilder sb = new StringBuilder(UsesNodeImpl.class.getSimpleName());
             sb.append("[groupingPath=" + groupingPath + "]");
             return sb.toString();
         }