X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Fbuilder%2Fimpl%2FUsesNodeBuilderImpl.java;h=ee07e8be4603ac99d14f68f2c0fbaf33abc97db6;hp=c54a0dc03673f315c349b98541d5465994db01e7;hb=ac39de5a9b96438d30df745895454c02e15e51e3;hpb=626c9943156ed658f0a4cf11858ccc19b9c316cf

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 c54a0dc036..ee07e8be46 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,53 +15,94 @@ 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.AbstractBuilder;
 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;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
 
-final class UsesNodeBuilderImpl implements UsesNodeBuilder {
-    private final UsesNodeImpl instance;
-    private final int line;
-    private final SchemaPath groupingPath;
+public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNodeBuilder {
+    private boolean isBuilt;
+    private UsesNodeImpl instance;
+    private 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>();
 
-    UsesNodeBuilderImpl(final String groupingPathStr, final int line) {
-        this.groupingPath = parseUsesPath(groupingPathStr);
-        this.line = line;
-        instance = new UsesNodeImpl(groupingPath);
+    public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {
+        super(moduleName, line);
+        this.groupingName = groupingName;
+    }
+
+    public UsesNodeBuilderImpl(UsesNodeBuilder b) {
+        super(b.getModuleName(), b.getLine());
+        groupingName = b.getGroupingName();
+        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;
     }
 
     @Override
-    public int getLine() {
-        return line;
+    public DataNodeContainerBuilder getParent() {
+        return parent;
+    }
+
+    @Override
+    public void setParent(Builder parent) {
+        if (!(parent instanceof DataNodeContainerBuilder)) {
+            throw new YangParseException(moduleName, line, "Unresolved parent of uses '" + groupingName + "'.");
+        }
+        this.parent = (DataNodeContainerBuilder) parent;
     }
 
     @Override
@@ -69,14 +110,49 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
         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
@@ -94,29 +170,54 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
         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);
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((groupingName == null) ? 0 : groupingName.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        UsesNodeBuilderImpl other = (UsesNodeBuilderImpl) obj;
+        if (groupingName == null) {
+            if (other.groupingName != null)
+                return false;
+        } else if (!groupingName.equals(other.groupingName))
+            return false;
+
+        if (parent == null) {
+            if (other.parent != null)
+                return false;
+        } else if (!parent.equals(other.parent))
+            return false;
+        if (refines == null) {
+            if (other.refines != null)
+                return false;
+        } else if (!refines.equals(other.refines))
+            return false;
+        return true;
     }
 
-    private final class UsesNodeImpl implements UsesNode {
+    @Override
+    public String toString() {
+        return "uses '" + groupingName + "'";
+    }
+
+    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;
@@ -132,8 +233,7 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
             return augmentations;
         }
 
-        private void setAugmentations(
-                final Set<AugmentationSchema> augmentations) {
+        private void setAugmentations(final Set<AugmentationSchema> augmentations) {
             if (augmentations != null) {
                 this.augmentations = augmentations;
             }
@@ -148,6 +248,15 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
             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;
@@ -159,14 +268,26 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
             }
         }
 
+        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;
         }
@@ -205,10 +326,10 @@ final class UsesNodeBuilderImpl implements UsesNodeBuilder {
 
         @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();
         }
     }
+
 }