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%2FModuleBuilder.java;h=e21e9f0483a1797161c5d0198ff0b4cb879109d1;hb=5794bed73531e9965287b6d0f20308791b5bfb70;hp=0007a751b3aac2a51424ba52c86c438e84b9b6f6;hpb=f9577cf3b936d143d78778758b1700616ceeadbe;p=yangtools.git

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java
index 0007a751b3..e21e9f0483 100644
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java
@@ -8,46 +8,13 @@
 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.Deque;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.TreeSet;
+import java.util.*;
 
 import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-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.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.parser.builder.api.*;
 import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.ModuleImportImpl;
 import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
 
@@ -60,36 +27,102 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
     private final ModuleImpl instance;
     private final String name;
+    private final String sourcePath;
     private final SchemaPath schemaPath;
     private URI namespace;
     private String prefix;
     private Date revision;
 
-    private final Deque<Builder> actualPath = new LinkedList<Builder>();
-    private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<TypeAwareBuilder>();
+    private final boolean submodule;
+    private String belongsTo;
+    private ModuleBuilder parent;
+
+    public ModuleBuilder getParent() {
+        return parent;
+    }
+
+    public void setParent(ModuleBuilder parent) {
+        this.parent = parent;
+    }
+
+    private final Deque<Builder> actualPath = new LinkedList<>();
+    private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<>();
 
     private final Set<ModuleImport> imports = new HashSet<ModuleImport>();
-    private final List<AugmentationSchemaBuilder> addedAugments = new ArrayList<AugmentationSchemaBuilder>();
-    private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<AugmentationSchemaBuilder>();
-    private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
-    private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<UsesNodeBuilder>();
-    private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<RpcDefinitionBuilder>();
-    private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();
-    private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<IdentitySchemaNodeBuilder>();
-    private final Set<FeatureBuilder> addedFeatures = new HashSet<FeatureBuilder>();
-    private final Set<DeviationBuilder> addedDeviations = new HashSet<DeviationBuilder>();
-    private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
-    private final List<ExtensionBuilder> addedExtensions = new ArrayList<ExtensionBuilder>();
+
+    private final Set<AugmentationSchema> augments = new HashSet<>();
+    private final List<AugmentationSchemaBuilder> augmentBuilders = new ArrayList<>();
+    private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
+
+    private final List<GroupingBuilder> allGroupings = new ArrayList<>();
+
+    private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<>();
+
+    private final Set<RpcDefinition> rpcs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+    private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<>();
+
+    private final Set<NotificationDefinition> notifications = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+    private final Set<NotificationBuilder> addedNotifications = new HashSet<>();
+
+    private final Set<IdentitySchemaNode> identities = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+    private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<>();
+
+    private final Set<FeatureDefinition> features = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+    private final Set<FeatureBuilder> addedFeatures = new HashSet<>();
+
+    private final Set<Deviation> deviations = new HashSet<>();
+    private final Set<DeviationBuilder> deviationBuilders = new HashSet<>();
+
+    private final List<ExtensionDefinition> extensions = new ArrayList<>();
+    private final List<ExtensionBuilder> addedExtensions = new ArrayList<>();
+
     private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
 
-    public ModuleBuilder(final String name) {
+    private final List<ListSchemaNodeBuilder> allLists = new ArrayList<ListSchemaNodeBuilder>();
+
+    public ModuleBuilder(final String name, final String sourcePath) {
+        this(name, false, sourcePath);
+    }
+
+    public ModuleBuilder(final String name, final boolean submodule, final String sourcePath) {
         super(name, 0, null);
         this.name = name;
+        this.sourcePath = sourcePath;
         schemaPath = new SchemaPath(Collections.<QName> emptyList(), true);
-        instance = new ModuleImpl(name);
+        this.submodule = submodule;
+        instance = new ModuleImpl(name, sourcePath);
         actualPath.push(this);
     }
 
+    public ModuleBuilder(Module base) {
+        super(base.getName(), 0, null);
+        this.name = base.getName();
+        this.sourcePath = base.getModuleSourcePath();
+        schemaPath = new SchemaPath(Collections.<QName> emptyList(), true);
+        submodule = false;
+        instance = new ModuleImpl(base.getName(), base.getModuleSourcePath());
+        actualPath.push(this);
+        namespace = base.getNamespace();
+        prefix = base.getPrefix();
+        revision = base.getRevision();
+
+        for (DataSchemaNode childNode : base.getChildNodes()) {
+            childNodes.add(childNode);
+        }
+
+        typedefs.addAll(base.getTypeDefinitions());
+        groupings.addAll(base.getGroupings());
+        usesNodes.addAll(base.getUses());
+        augments.addAll(base.getAugmentations());
+        rpcs.addAll(base.getRpcs());
+        notifications.addAll(base.getNotifications());
+        identities.addAll(base.getIdentities());
+        features.addAll(base.getFeatures());
+        deviations.addAll(base.getDeviations());
+        extensions.addAll(base.getExtensionSchemaNodes());
+        unknownNodes.addAll(base.getUnknownSchemaNodes());
+    }
+
     /**
      * Build new Module object based on this builder.
      */
@@ -101,71 +134,60 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         instance.setNamespace(namespace);
 
         // TYPEDEFS
-        final Set<TypeDefinition<?>> typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);
         for (TypeDefinitionBuilder tdb : addedTypedefs) {
             typedefs.add(tdb.build());
         }
         instance.setTypeDefinitions(typedefs);
 
         // CHILD NODES
-        final Map<QName, DataSchemaNode> children = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);
         for (DataSchemaNodeBuilder child : addedChildNodes) {
-            children.put(child.getQName(), child.build());
+            childNodes.add(child.build());
         }
-        instance.setChildNodes(children);
+        instance.addChildNodes(childNodes);
 
         // GROUPINGS
-        final Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
         for (GroupingBuilder gb : addedGroupings) {
             groupings.add(gb.build());
         }
         instance.setGroupings(groupings);
 
         // USES
-        final Set<UsesNode> usesDefinitions = new HashSet<UsesNode>();
         for (UsesNodeBuilder unb : addedUsesNodes) {
-            usesDefinitions.add(unb.build());
+            usesNodes.add(unb.build());
         }
-        instance.setUses(usesDefinitions);
+        instance.setUses(usesNodes);
 
         // FEATURES
-        final Set<FeatureDefinition> features = new TreeSet<FeatureDefinition>(Comparators.SCHEMA_NODE_COMP);
         for (FeatureBuilder fb : addedFeatures) {
             features.add(fb.build());
         }
         instance.setFeatures(features);
 
         // NOTIFICATIONS
-        final Set<NotificationDefinition> notifications = new TreeSet<NotificationDefinition>(
-                Comparators.SCHEMA_NODE_COMP);
         for (NotificationBuilder entry : addedNotifications) {
             notifications.add(entry.build());
         }
         instance.setNotifications(notifications);
 
         // AUGMENTATIONS
-        final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
-        for (AugmentationSchemaBuilder builder : addedAugments) {
-            augmentations.add(builder.build());
+        for (AugmentationSchemaBuilder builder : augmentBuilders) {
+            augments.add(builder.build());
         }
-        instance.setAugmentations(augmentations);
+        instance.setAugmentations(augments);
 
         // RPCs
-        final Set<RpcDefinition> rpcs = new TreeSet<RpcDefinition>(Comparators.SCHEMA_NODE_COMP);
         for (RpcDefinitionBuilder rpc : addedRpcs) {
             rpcs.add(rpc.build());
         }
         instance.setRpcs(rpcs);
 
         // DEVIATIONS
-        final Set<Deviation> deviations = new HashSet<Deviation>();
-        for (DeviationBuilder entry : addedDeviations) {
+        for (DeviationBuilder entry : deviationBuilders) {
             deviations.add(entry.build());
         }
         instance.setDeviations(deviations);
 
         // EXTENSIONS
-        final List<ExtensionDefinition> extensions = new ArrayList<ExtensionDefinition>();
         for (ExtensionBuilder eb : addedExtensions) {
             extensions.add(eb.build());
         }
@@ -173,29 +195,23 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         instance.setExtensionSchemaNodes(extensions);
 
         // IDENTITIES
-        final Set<IdentitySchemaNode> identities = new TreeSet<IdentitySchemaNode>(Comparators.SCHEMA_NODE_COMP);
         for (IdentitySchemaNodeBuilder id : addedIdentities) {
             identities.add(id.build());
         }
         instance.setIdentities(identities);
 
         // UNKNOWN NODES
-        final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
         for (UnknownSchemaNodeBuilder unb : addedUnknownNodes) {
             unknownNodes.add(unb.build());
         }
+        Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
         instance.setUnknownSchemaNodes(unknownNodes);
 
         return instance;
     }
 
-    public boolean isAllUsesDataCollected() {
-        for (UsesNodeBuilder usesNode : allUsesNodes) {
-            if (!usesNode.isDataCollected()) {
-                return false;
-            }
-        }
-        return true;
+    public String getModuleSourcePath() {
+        return sourcePath;
     }
 
     @Override
@@ -244,23 +260,55 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return dirtyNodes;
     }
 
+    public Set<AugmentationSchema> getAugments() {
+        return augments;
+    }
+
+    public List<AugmentationSchemaBuilder> getAugmentBuilders() {
+        return augmentBuilders;
+    }
+
     public List<AugmentationSchemaBuilder> getAllAugments() {
         return allAugments;
     }
 
-    public Set<IdentitySchemaNodeBuilder> getIdentities() {
+    public Set<IdentitySchemaNode> getIdentities() {
+        return identities;
+    }
+
+    public Set<IdentitySchemaNodeBuilder> getAddedIdentities() {
         return addedIdentities;
     }
 
+    public Set<FeatureDefinition> getFeatures() {
+        return features;
+    }
+
+    public Set<FeatureBuilder> getAddedFeatures() {
+        return addedFeatures;
+    }
+
+    public List<GroupingBuilder> getAllGroupings() {
+        return allGroupings;
+    }
+
     public List<UsesNodeBuilder> getAllUsesNodes() {
         return allUsesNodes;
     }
 
-    public Set<DeviationBuilder> getDeviations() {
-        return addedDeviations;
+    public Set<Deviation> getDeviations() {
+        return deviations;
+    }
+
+    public Set<DeviationBuilder> getDeviationBuilders() {
+        return deviationBuilders;
+    }
+
+    public List<ExtensionDefinition> getExtensions() {
+        return extensions;
     }
 
-    public List<ExtensionBuilder> getExtensions() {
+    public List<ExtensionBuilder> getAddedExtensions() {
         return addedExtensions;
     }
 
@@ -268,6 +316,10 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return allUnknownNodes;
     }
 
+    public List<ListSchemaNodeBuilder> getAllLists() {
+        return allLists;
+    }
+
     public String getName() {
         return name;
     }
@@ -288,6 +340,18 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return revision;
     }
 
+    public boolean isSubmodule() {
+        return submodule;
+    }
+
+    public String getBelongsTo() {
+        return belongsTo;
+    }
+
+    public void setBelongsTo(String belongsTo) {
+        this.belongsTo = belongsTo;
+    }
+
     public void markActualNodeDirty() {
         final TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) getActualNode();
         dirtyNodes.add(nodeBuilder);
@@ -330,14 +394,20 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return imports;
     }
 
-    public ExtensionBuilder addExtension(final QName qname, final int line) {
+    public ExtensionBuilder addExtension(final QName qname, final int line, final SchemaPath path) {
+        Builder parent = getActualNode();
+        if (!(parent.equals(this))) {
+            throw new YangParseException(name, line, "extension can be defined only in module or submodule");
+        }
+
         final String extName = qname.getLocalName();
         for (ExtensionBuilder addedExtension : addedExtensions) {
             if (addedExtension.getQName().getLocalName().equals(extName)) {
                 raiseYangParserException("extension", "node", extName, line, addedExtension.getLine());
             }
         }
-        final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname);
+        final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname, path);
+        builder.setParent(parent);
         addedExtensions.add(builder);
         return builder;
     }
@@ -358,6 +428,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         Builder parent = getActualNode();
         builder.setParent(parent);
         addChildToParent(parent, builder, qname.getLocalName());
+        allLists.add(builder);
 
         return builder;
     }
@@ -382,8 +453,8 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return builder;
     }
 
-    public GroupingBuilder addGrouping(final int line, final QName qname) {
-        final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname);
+    public GroupingBuilder addGrouping(final int line, final QName qname, final SchemaPath path) {
+        final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname, path);
 
         Builder parent = getActualNode();
         builder.setParent(parent);
@@ -418,6 +489,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
             }
         }
 
+        allGroupings.add(builder);
         return builder;
     }
 
@@ -429,10 +501,21 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         if (parent.equals(this)) {
             // augment can be declared only under 'module' ...
-            addedAugments.add(builder);
+            if (!(augmentTargetStr.startsWith("/"))) {
+                throw new YangParseException(
+                        name,
+                        line,
+                        "If the 'augment' statement is on the top level in a module, the absolute form of a schema node identifier MUST be used.");
+            }
+            augmentBuilders.add(builder);
         } else {
             // ... or 'uses' statement
             if (parent instanceof UsesNodeBuilder) {
+                if (augmentTargetStr.startsWith("/")) {
+                    throw new YangParseException(name, line,
+                            "If 'augment' statement is a substatement to the 'uses' statement, it cannot contain absolute path ("
+                                    + augmentTargetStr + ")");
+                }
                 ((UsesNodeBuilder) parent).addAugment(builder);
             } else {
                 throw new YangParseException(name, line, "Augment can be declared only under module or uses statement.");
@@ -443,11 +526,6 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return builder;
     }
 
-    @Override
-    public Set<UsesNodeBuilder> getUsesNodes() {
-        return addedUsesNodes;
-    }
-
     @Override
     public void addUsesNode(UsesNodeBuilder usesBuilder) {
         addedUsesNodes.add(usesBuilder);
@@ -468,9 +546,8 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
             }
             ((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
         }
-        if(parent instanceof AugmentationSchemaBuilder) {
+        if (parent instanceof AugmentationSchemaBuilder) {
             usesBuilder.setAugmenting(true);
-            usesBuilder.setParentAugment((AugmentationSchemaBuilder)parent);
         }
 
         allUsesNodes.add(usesBuilder);
@@ -486,13 +563,13 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         refine.setParent(parent);
     }
 
-    public RpcDefinitionBuilder addRpc(final int line, final QName qname) {
+    public RpcDefinitionBuilder addRpc(final int line, final QName qname, final SchemaPath path) {
         Builder parent = getActualNode();
         if (!(parent.equals(this))) {
             throw new YangParseException(name, line, "rpc can be defined only in module or submodule");
         }
 
-        final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname);
+        final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname, path);
         rpcBuilder.setParent(parent);
 
         String rpcName = qname.getLocalName();
@@ -543,7 +620,11 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return outputBuilder;
     }
 
-    public NotificationBuilder addNotification(final int line, final QName qname) {
+    public void addNotification(NotificationDefinition notification) {
+        notifications.add(notification);
+    }
+
+    public NotificationBuilder addNotification(final int line, final QName qname, final SchemaPath path) {
         final Builder parent = getActualNode();
         if (!(parent.equals(this))) {
             throw new YangParseException(name, line, "notification can be defined only in module or submodule");
@@ -566,20 +647,20 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
             }
         }
 
-        final NotificationBuilder builder = new NotificationBuilder(name, line, qname);
+        final NotificationBuilder builder = new NotificationBuilder(name, line, qname, path);
         builder.setParent(parent);
         addedNotifications.add(builder);
 
         return builder;
     }
 
-    public FeatureBuilder addFeature(final int line, final QName qname) {
+    public FeatureBuilder addFeature(final int line, final QName qname, final SchemaPath path) {
         Builder parent = getActualNode();
         if (!(parent.equals(this))) {
             throw new YangParseException(name, line, "feature can be defined only in module or submodule");
         }
 
-        final FeatureBuilder builder = new FeatureBuilder(name, line, qname);
+        final FeatureBuilder builder = new FeatureBuilder(name, line, qname, path);
         builder.setParent(parent);
 
         String featureName = qname.getLocalName();
@@ -592,8 +673,8 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return builder;
     }
 
-    public ChoiceBuilder addChoice(final int line, final QName qname) {
-        final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname);
+    public ChoiceBuilder addChoice(final int line, final QName qname, final SchemaPath path) {
+        final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname, path);
 
         Builder parent = getActualNode();
         builder.setParent(parent);
@@ -602,13 +683,13 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return builder;
     }
 
-    public ChoiceCaseBuilder addCase(final int line, final QName qname) {
+    public ChoiceCaseBuilder addCase(final int line, final QName qname, final SchemaPath path) {
         Builder parent = getActualNode();
         if (parent == null || parent.equals(this)) {
             throw new YangParseException(name, line, "'case' parent not found");
         }
 
-        final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname);
+        final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname, path);
         builder.setParent(parent);
 
         if (parent instanceof ChoiceBuilder) {
@@ -643,8 +724,8 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         addedTypedefs.add(typedefBuilder);
     }
 
-    public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname) {
-        final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname);
+    public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname, final SchemaPath path) {
+        final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname, path);
 
         Builder parent = getActualNode();
         builder.setParent(parent);
@@ -731,11 +812,11 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         final DeviationBuilder builder = new DeviationBuilder(name, line, targetPath);
         builder.setParent(parent);
-        addedDeviations.add(builder);
+        deviationBuilders.add(builder);
         return builder;
     }
 
-    public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line) {
+    public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line, final SchemaPath path) {
         Builder parent = getActualNode();
         if (!(parent.equals(this))) {
             throw new YangParseException(name, line, "identity can be defined only in module or submodule");
@@ -747,7 +828,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
             }
         }
 
-        final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname);
+        final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname, path);
         builder.setParent(parent);
         addedIdentities.add(builder);
         return builder;
@@ -759,9 +840,9 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         allUnknownNodes.add(builder);
     }
 
-    public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname) {
+    public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname, final SchemaPath path) {
         final Builder parent = getActualNode();
-        final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname);
+        final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname, path);
         builder.setParent(parent);
         allUnknownNodes.add(builder);
 
@@ -783,11 +864,19 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return builder;
     }
 
-    public Set<RpcDefinitionBuilder> getRpcs() {
+    public Set<RpcDefinition> getRpcs() {
+        return rpcs;
+    }
+
+    public Set<RpcDefinitionBuilder> getAddedRpcs() {
         return addedRpcs;
     }
 
-    public Set<NotificationBuilder> getNotifications() {
+    public Set<NotificationDefinition> getNotifications() {
+        return notifications;
+    }
+
+    public Set<NotificationBuilder> getAddedNotifications() {
         return addedNotifications;
     }
 
@@ -796,9 +885,10 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         return "module " + name;
     }
 
-    private final class ModuleImpl implements Module {
+    private static final class ModuleImpl implements Module {
         private URI namespace;
         private final String name;
+        private final String sourcePath;
         private Date revision;
         private String prefix;
         private String yangVersion;
@@ -806,22 +896,28 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         private String reference;
         private String organization;
         private String contact;
-        private Set<ModuleImport> imports = Collections.emptySet();
-        private Set<FeatureDefinition> features = Collections.emptySet();
-        private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
-        private Set<NotificationDefinition> notifications = Collections.emptySet();
-        private Set<AugmentationSchema> augmentations = Collections.emptySet();
-        private Set<RpcDefinition> rpcs = Collections.emptySet();
-        private Set<Deviation> deviations = Collections.emptySet();
-        private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
-        private Set<GroupingDefinition> groupings = Collections.emptySet();
-        private Set<UsesNode> uses = Collections.emptySet();
-        private List<ExtensionDefinition> extensionNodes = Collections.emptyList();
-        private Set<IdentitySchemaNode> identities = Collections.emptySet();
-        private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
-
-        private ModuleImpl(String name) {
+        private final Set<ModuleImport> imports = new HashSet<>();
+        private final Set<FeatureDefinition> features = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+        private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+        private final Set<NotificationDefinition> notifications = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+        private final Set<AugmentationSchema> augmentations = new HashSet<>();
+        private final Set<RpcDefinition> rpcs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+        private final Set<Deviation> deviations = new HashSet<>();
+        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<UsesNode> uses = new HashSet<>();
+        private final List<ExtensionDefinition> extensionNodes = new ArrayList<>();
+        private final Set<IdentitySchemaNode> identities = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+        private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+
+        private ModuleImpl(String name, String sourcePath) {
             this.name = name;
+            this.sourcePath = sourcePath;
+        }
+
+        @Override
+        public String getModuleSourcePath() {
+            return sourcePath;
         }
 
         @Override
@@ -908,7 +1004,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setImports(Set<ModuleImport> imports) {
             if (imports != null) {
-                this.imports = imports;
+                this.imports.addAll(imports);
             }
         }
 
@@ -919,7 +1015,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setFeatures(Set<FeatureDefinition> features) {
             if (features != null) {
-                this.features = features;
+                this.features.addAll(features);
             }
         }
 
@@ -930,7 +1026,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
             if (typeDefinitions != null) {
-                this.typeDefinitions = typeDefinitions;
+                this.typeDefinitions.addAll(typeDefinitions);
             }
         }
 
@@ -941,7 +1037,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setNotifications(Set<NotificationDefinition> notifications) {
             if (notifications != null) {
-                this.notifications = notifications;
+                this.notifications.addAll(notifications);
             }
         }
 
@@ -952,7 +1048,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setAugmentations(Set<AugmentationSchema> augmentations) {
             if (augmentations != null) {
-                this.augmentations = augmentations;
+                this.augmentations.addAll(augmentations);
             }
         }
 
@@ -963,7 +1059,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setRpcs(Set<RpcDefinition> rpcs) {
             if (rpcs != null) {
-                this.rpcs = rpcs;
+                this.rpcs.addAll(rpcs);
             }
         }
 
@@ -974,18 +1070,18 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setDeviations(Set<Deviation> deviations) {
             if (deviations != null) {
-                this.deviations = deviations;
+                this.deviations.addAll(deviations);
             }
         }
 
         @Override
         public Set<DataSchemaNode> getChildNodes() {
-            return new LinkedHashSet<DataSchemaNode>(childNodes.values());
+            return Collections.unmodifiableSet(childNodes);
         }
 
-        private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+        private void addChildNodes(Set<DataSchemaNode> childNodes) {
             if (childNodes != null) {
-                this.childNodes = childNodes;
+                this.childNodes.addAll(childNodes);
             }
         }
 
@@ -996,7 +1092,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setGroupings(Set<GroupingDefinition> groupings) {
             if (groupings != null) {
-                this.groupings = groupings;
+                this.groupings.addAll(groupings);
             }
         }
 
@@ -1007,18 +1103,19 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setUses(Set<UsesNode> uses) {
             if (uses != null) {
-                this.uses = uses;
+                this.uses.addAll(uses);
             }
         }
 
         @Override
         public List<ExtensionDefinition> getExtensionSchemaNodes() {
+            Collections.sort(extensionNodes, Comparators.SCHEMA_NODE_COMP);
             return extensionNodes;
         }
 
         private void setExtensionSchemaNodes(final List<ExtensionDefinition> extensionNodes) {
             if (extensionNodes != null) {
-                this.extensionNodes = extensionNodes;
+                this.extensionNodes.addAll(extensionNodes);
             }
         }
 
@@ -1029,7 +1126,7 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setIdentities(final Set<IdentitySchemaNode> identities) {
             if (identities != null) {
-                this.identities = identities;
+                this.identities.addAll(identities);
             }
         }
 
@@ -1040,25 +1137,18 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
 
         private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
             if (unknownNodes != null) {
-                this.unknownNodes = unknownNodes;
+                this.unknownNodes.addAll(unknownNodes);
             }
         }
 
         @Override
         public DataSchemaNode getDataChildByName(QName name) {
-            return childNodes.get(name);
+            return getChildNode(childNodes, name);
         }
 
         @Override
         public DataSchemaNode getDataChildByName(String name) {
-            DataSchemaNode result = null;
-            for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
-                if (entry.getKey().getLocalName().equals(name)) {
-                    result = entry.getValue();
-                    break;
-                }
-            }
-            return result;
+            return getChildNode(childNodes, name);
         }
 
         @Override
@@ -1214,9 +1304,6 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
      */
     private void addChildToSubnodeOfModule(final Builder parent, final DataSchemaNodeBuilder child,
             final String childName, final int lineNum) {
-        if (parent instanceof AugmentationSchemaBuilder) {
-            child.setAugmenting(true);
-        }
         // no need for checking rpc and notification because they can be
         // defined only under module or submodule
         if (parent instanceof DataNodeContainerBuilder) {
@@ -1240,91 +1327,6 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
         }
     }
 
-    /**
-     *
-     * Implementation of <code>ModuleImport</code> interface only for the method
-     * {@link ModuleBuilder#createModuleImport(String, Date, String)
-     * createModuleImport}.
-     *
-     */
-    private class ModuleImportImpl implements ModuleImport {
-        final String moduleName;
-        final Date revision;
-        final String prefix;
-
-        private ModuleImportImpl(final String moduleName, final Date revision, final String prefix) {
-            this.moduleName = moduleName;
-            this.revision = revision;
-            this.prefix = prefix;
-        }
-
-        @Override
-        public String getModuleName() {
-            return moduleName;
-        }
-
-        @Override
-        public Date getRevision() {
-            return revision;
-        }
-
-        @Override
-        public String getPrefix() {
-            return prefix;
-        }
-
-        @Override
-        public int hashCode() {
-            final int prime = 31;
-            int result = 1;
-            result = prime * result + ((moduleName == null) ? 0 : moduleName.hashCode());
-            result = prime * result + ((revision == null) ? 0 : revision.hashCode());
-            result = prime * result + ((prefix == null) ? 0 : prefix.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;
-            }
-            ModuleImport other = (ModuleImport) obj;
-            if (getModuleName() == null) {
-                if (other.getModuleName() != null) {
-                    return false;
-                }
-            } else if (!getModuleName().equals(other.getModuleName())) {
-                return false;
-            }
-            if (getRevision() == null) {
-                if (other.getRevision() != null) {
-                    return false;
-                }
-            } else if (!getRevision().equals(other.getRevision())) {
-                return false;
-            }
-            if (getPrefix() == null) {
-                if (other.getPrefix() != null) {
-                    return false;
-                }
-            } else if (!getPrefix().equals(other.getPrefix())) {
-                return false;
-            }
-            return true;
-        }
-
-        @Override
-        public String toString() {
-            return "ModuleImport[moduleName=" + moduleName + ", revision=" + revision + ", prefix=" + prefix + "]";
-        }
-    }
-
     private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {
         final ModuleImport moduleImport = new ModuleImportImpl(moduleName, revision, prefix);
         return moduleImport;