X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fbuilder%2Fimpl%2FGroupingBuilderImpl.java;h=90a49d1b196f30986c11d84713e3e4eb53a637b6;hb=refs%2Fchanges%2F22%2F6922%2F5;hp=e2bf02ce186bdd1886a1fddbbe57ed868e4b9196;hpb=116f9289f8930a7d46d8669a741d05a0a3495752;p=yangtools.git

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/GroupingBuilderImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/GroupingBuilderImpl.java
index e2bf02ce18..90a49d1b19 100644
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/GroupingBuilderImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/GroupingBuilderImpl.java
@@ -8,13 +8,10 @@
 package org.opendaylight.yangtools.yang.parser.builder.impl;
 
 import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.TreeSet;
 
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
@@ -30,31 +27,38 @@ import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
 import org.opendaylight.yangtools.yang.parser.util.CopyUtils;
 import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
 
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
 public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder implements GroupingBuilder {
-    private boolean isBuilt;
-    private final GroupingDefinitionImpl instance;
+    private GroupingDefinitionImpl instance;
+    // SchemaNode args
     private SchemaPath schemaPath;
+    private String description;
+    private String reference;
+    private Status status = Status.CURRENT;
+    // DataSchemaNode args
+    private boolean addedByUses;
 
     public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
         super(moduleName, line, qname);
         schemaPath = path;
-        instance = new GroupingDefinitionImpl(qname, path);
     }
 
-    public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final GroupingDefinition base) {
+    public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path,
+            final GroupingDefinition base) {
         super(moduleName, line, base.getQName());
         schemaPath = path;
-        instance = new GroupingDefinitionImpl(qname, path);
 
-        instance.description = base.getDescription();
-        instance.reference = base.getReference();
-        instance.status = base.getStatus();
-        instance.addedByUses = base.isAddedByUses();
+        description = base.getDescription();
+        reference = base.getReference();
+        status = base.getStatus();
+        addedByUses = base.isAddedByUses();
 
         URI ns = qname.getNamespace();
         Date rev = qname.getRevision();
@@ -65,45 +69,51 @@ public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder
         addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
                 rev, pref));
 
-        instance.uses.addAll(base.getUses());
+        usesNodes.addAll(base.getUses());
     }
 
     @Override
     public GroupingDefinition build() {
-        if (!isBuilt) {
-            // CHILD NODES
-            for (DataSchemaNodeBuilder node : addedChildNodes) {
-                childNodes.add(node.build());
-            }
-            instance.addChildNodes(childNodes);
+        if (instance != null) {
+            return instance;
+        }
 
-            // GROUPINGS
-            for (GroupingBuilder builder : addedGroupings) {
-                groupings.add(builder.build());
-            }
-            instance.addGroupings(groupings);
+        instance = new GroupingDefinitionImpl(qname, schemaPath);
 
-            // TYPEDEFS
-            for (TypeDefinitionBuilder entry : addedTypedefs) {
-                typedefs.add(entry.build());
-            }
-            instance.addTypeDefinitions(typedefs);
+        instance.description = description;
+        instance.reference = reference;
+        instance.status = status;
+        instance.addedByUses = addedByUses;
 
-            // USES
-            for (UsesNodeBuilder builder : addedUsesNodes) {
-                usesNodes.add(builder.build());
-            }
-            instance.addUses(usesNodes);
+        // CHILD NODES
+        for (DataSchemaNodeBuilder node : addedChildNodes) {
+            childNodes.add(node.build());
+        }
+        instance.childNodes = ImmutableSet.copyOf(childNodes);
 
-            // UNKNOWN NODES
-            for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
-                unknownNodes.add(b.build());
-            }
-            Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
-            instance.addUnknownSchemaNodes(unknownNodes);
+        // GROUPINGS
+        for (GroupingBuilder builder : addedGroupings) {
+            groupings.add(builder.build());
+        }
+        instance.groupings = ImmutableSet.copyOf(groupings);
+
+        // TYPEDEFS
+        for (TypeDefinitionBuilder entry : addedTypedefs) {
+            typedefs.add(entry.build());
+        }
+        instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
 
-            isBuilt = true;
+        // USES
+        for (UsesNodeBuilder builder : addedUsesNodes) {
+            usesNodes.add(builder.build());
         }
+        instance.uses = ImmutableSet.copyOf(usesNodes);
+
+        // UNKNOWN NODES
+        for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+            unknownNodes.add(b.build());
+        }
+        instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 
         return instance;
     }
@@ -174,46 +184,49 @@ public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder
         return schemaPath;
     }
 
+    @Override
+    public void setPath(final SchemaPath path) {
+        this.schemaPath = path;
+    }
+
     @Override
     public String getDescription() {
-        return instance.description;
+        return description;
     }
 
     @Override
     public void setDescription(final String description) {
-        instance.description = description;
+        this.description = description;
     }
 
     @Override
     public String getReference() {
-        return instance.reference;
+        return reference;
     }
 
     @Override
     public void setReference(final String reference) {
-        instance.reference = reference;
+        this.reference = reference;
     }
 
     @Override
     public Status getStatus() {
-        return instance.status;
+        return status;
     }
 
     @Override
     public void setStatus(Status status) {
-        if (status != null) {
-            instance.status = status;
-        }
+        this.status = Preconditions.checkNotNull(status, "status cannot be null");
     }
 
     @Override
     public boolean isAddedByUses() {
-        return instance.addedByUses;
+        return addedByUses;
     }
 
     @Override
     public void setAddedByUses(final boolean addedByUses) {
-        instance.addedByUses = addedByUses;
+        this.addedByUses = addedByUses;
     }
 
     @Override
@@ -262,7 +275,6 @@ public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder
         return true;
     }
 
-
     private static final class GroupingDefinitionImpl implements GroupingDefinition {
         private final QName qname;
         private final SchemaPath path;
@@ -270,11 +282,11 @@ public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder
         private String reference;
         private Status status;
         private boolean addedByUses;
-        private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
-        private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
-        private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
-        private final Set<UsesNode> uses = new HashSet<>();
-        private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+        private ImmutableSet<DataSchemaNode> childNodes;
+        private ImmutableSet<GroupingDefinition> groupings;
+        private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+        private ImmutableSet<UsesNode> uses;
+        private ImmutableList<UnknownSchemaNode> unknownNodes;
 
         private GroupingDefinitionImpl(final QName qname, final SchemaPath path) {
             this.qname = qname;
@@ -313,57 +325,27 @@ public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder
 
         @Override
         public Set<DataSchemaNode> getChildNodes() {
-            return Collections.unmodifiableSet(childNodes);
-        }
-
-        private void addChildNodes(Set<DataSchemaNode> childNodes) {
-            if (childNodes != null) {
-                this.childNodes.addAll(childNodes);
-            }
+            return childNodes;
         }
 
         @Override
         public Set<GroupingDefinition> getGroupings() {
-            return Collections.unmodifiableSet(groupings);
-        }
-
-        private void addGroupings(Set<GroupingDefinition> groupings) {
-            if (groupings != null) {
-                this.groupings.addAll(groupings);
-            }
+            return groupings;
         }
 
         @Override
         public Set<UsesNode> getUses() {
-            return Collections.unmodifiableSet(uses);
-        }
-
-        private void addUses(Set<UsesNode> uses) {
-            if (uses != null) {
-                this.uses.addAll(uses);
-            }
+            return uses;
         }
 
         @Override
         public Set<TypeDefinition<?>> getTypeDefinitions() {
-            return Collections.unmodifiableSet(typeDefinitions);
-        }
-
-        private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
-            if (typeDefinitions != null) {
-                this.typeDefinitions.addAll(typeDefinitions);
-            }
+            return typeDefinitions;
         }
 
         @Override
         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
-            return Collections.unmodifiableList(unknownNodes);
-        }
-
-        private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
-            if (unknownNodes != null) {
-                this.unknownNodes.addAll(unknownNodes);
-            }
+            return unknownNodes;
         }
 
         @Override