import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
+
import org.apache.commons.io.IOUtils;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
}
public static Set<DataSchemaNodeBuilder> wrapChildNodes(final String moduleName, final int line,
- final Set<DataSchemaNode> nodes, final SchemaPath parentPath, final URI ns, final Date rev,
- final String pref) {
+ final Set<DataSchemaNode> nodes, final SchemaPath parentPath, final QName parentQName) {
Set<DataSchemaNodeBuilder> result = new HashSet<>();
for (DataSchemaNode node : nodes) {
- QName qname = new QName(ns, rev, pref, node.getQName().getLocalName());
+ QName qname = QName.create(parentQName, node.getQName().getLocalName());
DataSchemaNodeBuilder wrapped = wrapChildNode(moduleName, line, node, parentPath, qname);
result.add(wrapped);
}
}
public static Set<GroupingBuilder> wrapGroupings(final String moduleName, final int line,
- final Set<GroupingDefinition> nodes, final SchemaPath parentPath, final URI ns, final Date rev,
- final String pref) {
+ final Set<GroupingDefinition> nodes, final SchemaPath parentPath, final QName parentQName) {
Set<GroupingBuilder> result = new HashSet<>();
for (GroupingDefinition node : nodes) {
- QName qname = new QName(ns, rev, pref, node.getQName().getLocalName());
+ QName qname = QName.create(parentQName, node.getQName().getLocalName());
SchemaPath schemaPath = parentPath.createChild(qname);
result.add(new GroupingBuilderImpl(moduleName, line, qname, schemaPath, node));
}
}
public static Set<TypeDefinitionBuilder> wrapTypedefs(final String moduleName, final int line,
- final DataNodeContainer dataNode, final SchemaPath parentPath, final URI ns, final Date rev,
- final String pref) {
+ final DataNodeContainer dataNode, final SchemaPath parentPath, final QName parentQName) {
Set<TypeDefinition<?>> nodes = dataNode.getTypeDefinitions();
Set<TypeDefinitionBuilder> result = new HashSet<>();
for (TypeDefinition<?> node : nodes) {
- QName qname = new QName(ns, rev, pref, node.getQName().getLocalName());
+ QName qname = QName.create(parentQName, node.getQName().getLocalName());
SchemaPath schemaPath = parentPath.createChild(qname);
result.add(new TypeDefinitionBuilderImpl(moduleName, line, qname, schemaPath, ((ExtendedType) node)));
}
}
public static List<UnknownSchemaNodeBuilderImpl> wrapUnknownNodes(final String moduleName, final int line,
- final List<UnknownSchemaNode> nodes, final SchemaPath parentPath, final URI ns, final Date rev,
- final String pref) {
+ final List<UnknownSchemaNode> nodes, final SchemaPath parentPath, final QName parentQName) {
List<UnknownSchemaNodeBuilderImpl> result = new ArrayList<>();
for (UnknownSchemaNode node : nodes) {
- QName qname = new QName(ns, rev, pref, node.getQName().getLocalName());
+ QName qname = QName.create(parentQName, node.getQName().getLocalName());
SchemaPath schemaPath = parentPath.createChild(qname);
result.add(new UnknownSchemaNodeBuilderImpl(moduleName, line, qname, schemaPath, node));
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
+
import java.util.ArrayList;
-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.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder,
- AugmentationTargetBuilder {
+AugmentationTargetBuilder {
private ChoiceNodeImpl instance;
// DataSchemaNode args
configuration = base.isConfiguration();
augmentations.addAll(base.getAvailableAugmentations());
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
Set<DataSchemaNodeBuilder> wrapped = BuilderUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
- base.getCases()), path, ns, rev, pref);
+ base.getCases()), path, qname);
for (DataSchemaNodeBuilder wrap : wrapped) {
if (wrap instanceof ChoiceCaseBuilder) {
caseBuilders.add((ChoiceCaseBuilder) wrap);
}
}
- addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
- rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
+ qname));
}
@Override
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
+
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class ChoiceCaseBuilder extends AbstractDocumentedDataNodeContainerBuilder implements DataSchemaNodeBuilder,
- AugmentationTargetBuilder {
+AugmentationTargetBuilder {
private ChoiceCaseNodeImpl instance;
// SchemaNode args
private SchemaPath schemaPath;
augmenting = base.isAugmenting();
addedByUses = base.isAddedByUses();
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
- addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
- rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
+ qname));
augmentations.addAll(base.getAvailableAugmentations());
}
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
-import java.util.Date;
+
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
status = base.getStatus();
addedByUses = base.isAddedByUses();
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
- ns, rev, pref));
+ qname));
}
@Override
}
private static final class GroupingDefinitionImpl extends AbstractDocumentedDataNodeContainer implements
- GroupingDefinition {
+ GroupingDefinition {
private final QName qname;
private final SchemaPath path;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
+
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
public final class ListSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements DataSchemaNodeBuilder,
- AugmentationTargetBuilder {
+AugmentationTargetBuilder {
private ListSchemaNodeImpl instance;
private boolean userOrdered;
private List<String> keys;
addedByUses = base.isAddedByUses();
configuration = base.isConfiguration();
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
- addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
- rev, pref));
-
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
+ qname));
augmentations.addAll(base.getAvailableAugmentations());
}
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
+
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class NotificationBuilder extends AbstractDocumentedDataNodeContainerBuilder implements SchemaNodeBuilder,
- AugmentationTargetBuilder {
+AugmentationTargetBuilder {
private NotificationDefinitionImpl instance;
// SchemaNode args
private SchemaPath schemaPath;
super(moduleName, line, qname, path, base);
this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
- ns, rev, pref));
-
+ qname));
augmentations.addAll(base.getAvailableAugmentations());
}
}
private static final class NotificationDefinitionImpl extends AbstractDocumentedDataNodeContainer implements
- NotificationDefinition {
+ NotificationDefinition {
private final QName qname;
private final SchemaPath path;
private ImmutableSet<AugmentationSchema> augmentations;
*/
package org.opendaylight.yangtools.yang.parser.builder.util;
-import java.net.URI;
-import java.util.Date;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
super(moduleName, line);
this.qname = qname;
- URI ns = qname.getNamespace();
- Date rev = qname.getRevision();
- String pref = qname.getPrefix();
-
// We do copy of child nodes with namespace change
// FIXME: Copy should be part of builder API so impl we prevent
// cyclic dependencies and each builder carries its own semantic for copy.
- addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, qname));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, qname));
+ addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, qname));
// FIXME: unkownSchemaNodes should be available in DataNodeContainer
-// addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
-// rev, pref));
+ // addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName,
+ // line, base.getUnknownSchemaNodes(), path, qname));
usesNodes.addAll(base.getUses());
}
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
DataNodeContainerBuilder parent = usesNode.getParent();
ModuleBuilder module = BuilderUtils.getParentModule(parent);
SchemaPath parentPath;
- URI ns;
- Date rev;
- String pref;
+
+ final QName parentQName;
if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
- ns = module.getNamespace();
- rev = module.getRevision();
- pref = module.getPrefix();
+ parentQName = QName.create(module.getQNameModule(), module.getPrefix(), "dummy");
if (parent instanceof AugmentationSchemaBuilder) {
parentPath = ((AugmentationSchemaBuilder) parent).getTargetNodeSchemaPath();
} else {
parentPath = parent.getPath();
}
} else {
- ns = parent.getQName().getNamespace();
- rev = parent.getQName().getRevision();
- pref = parent.getQName().getPrefix();
+ parentQName = parent.getQName();
parentPath = parent.getPath();
}
GroupingDefinition gd = usesNode.getGroupingDefinition();
Set<DataSchemaNodeBuilder> childNodes = wrapChildNodes(module.getModuleName(), line, gd.getChildNodes(),
- parentPath, ns, rev, pref);
+ parentPath, parentQName);
parent.getChildNodeBuilders().addAll(childNodes);
for (DataSchemaNodeBuilder childNode : childNodes) {
setNodeAddedByUses(childNode);
}
- Set<TypeDefinitionBuilder> typedefs = wrapTypedefs(module.getModuleName(), line, gd, parentPath, ns, rev, pref);
+ Set<TypeDefinitionBuilder> typedefs = wrapTypedefs(module.getModuleName(), line, gd, parentPath, parentQName);
parent.getTypeDefinitionBuilders().addAll(typedefs);
for (TypeDefinitionBuilder typedef : typedefs) {
setNodeAddedByUses(typedef);
}
Set<GroupingBuilder> groupings = wrapGroupings(module.getModuleName(), line, usesNode.getGroupingDefinition()
- .getGroupings(), parentPath, ns, rev, pref);
+ .getGroupings(), parentPath, parentQName);
parent.getGroupingBuilders().addAll(groupings);
for (GroupingBuilder gb : groupings) {
setNodeAddedByUses(gb);
}
List<UnknownSchemaNodeBuilderImpl> unknownNodes = wrapUnknownNodes(module.getModuleName(), line,
- gd.getUnknownSchemaNodes(), parentPath, ns, rev, pref);
+ gd.getUnknownSchemaNodes(), parentPath, parentQName);
parent.getUnknownNodes().addAll(unknownNodes);
for (UnknownSchemaNodeBuilder un : unknownNodes) {
un.setAddedByUses(true);