import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Collections2;
+import com.google.common.collect.Iterables;
import com.google.common.io.ByteSource;
-
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
+import java.net.URI;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
-
+import org.antlr.v4.runtime.tree.ParseTree;
import org.apache.commons.io.IOUtils;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_stmtContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Namespace_stmtContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtsContext;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils;
+import org.opendaylight.yangtools.yang.parser.impl.util.YangModelDependencyInfo;
import org.opendaylight.yangtools.yang.parser.util.NamedByteArrayInputStream;
import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class BuilderUtils {
+ private static final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
private static final Logger LOG = LoggerFactory.getLogger(BuilderUtils.class);
private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings();
private static final Splitter COLON_SPLITTER = Splitter.on(':');
return dependentModule;
}
+ public static ModuleBuilder findModuleFromBuilders(ModuleImport imp, Iterable<ModuleBuilder> modules) {
+ String name = imp.getModuleName();
+ Date revision = imp.getRevision();
+ TreeMap<Date, ModuleBuilder> map = new TreeMap<>();
+ for (ModuleBuilder module : modules) {
+ if (module != null) {
+ if (module.getName().equals(name)) {
+ map.put(module.getRevision(), module);
+ }
+ }
+ }
+ if (map.isEmpty()) {
+ return null;
+ }
+ if (revision == null) {
+ return map.lastEntry().getValue();
+ }
+ return map.get(revision);
+ }
+
/**
* Find module from context based on prefix.
*
return result;
}
- /**
- * Parse XPath string.
- *
- * @param xpathString
- * XPath as String
- * @return SchemaPath from given String
- */
- public static SchemaPath parseXPathString(final String xpathString) {
- final boolean absolute = !xpathString.isEmpty() && xpathString.charAt(0) == '/';
-
- final List<QName> path = new ArrayList<>();
- for (String pathElement : SLASH_SPLITTER.split(xpathString)) {
- final Iterator<String> it = COLON_SPLITTER.split(pathElement).iterator();
- final String s = it.next();
-
- final QName name;
- if (it.hasNext()) {
- name = QName.create(QNameModule.create(null, null), s, it.next());
- } else {
- name = QName.create(QNameModule.create(null, null), s);
- }
- path.add(name);
- }
- return SchemaPath.create(path, absolute);
- }
-
/**
* Add all augment's child nodes to given target.
*
}
}
- public static DataSchemaNodeBuilder findSchemaNode(final List<QName> path, final SchemaNodeBuilder parentNode) {
- DataSchemaNodeBuilder node = null;
+ public static SchemaNodeBuilder findSchemaNode(final Iterable<QName> path, final SchemaNodeBuilder parentNode) {
+ SchemaNodeBuilder node = null;
SchemaNodeBuilder parent = parentNode;
+ int size = Iterables.size(path);
int i = 0;
- while (i < path.size()) {
- String name = path.get(i).getLocalName();
+ for (QName qname : path) {
+ String name = qname.getLocalName();
if (parent instanceof DataNodeContainerBuilder) {
node = ((DataNodeContainerBuilder) parent).getDataChildByName(name);
+ if (node == null) {
+ node = findUnknownNode(name, parent);
+ }
} else if (parent instanceof ChoiceBuilder) {
node = ((ChoiceBuilder) parent).getCaseNodeByName(name);
+ if (node == null) {
+ node = findUnknownNode(name, parent);
+ }
} else if (parent instanceof RpcDefinitionBuilder) {
if ("input".equals(name)) {
node = ((RpcDefinitionBuilder) parent).getInput();
} else if ("output".equals(name)) {
node = ((RpcDefinitionBuilder) parent).getOutput();
} else {
- return null;
+ if (node == null) {
+ node = findUnknownNode(name, parent);
+ }
}
} else {
- return null;
+ node = findUnknownNode(name, parent);
}
- if (i < path.size() - 1) {
+ if (i < size - 1) {
parent = node;
}
i = i + 1;
return node;
}
+ private static UnknownSchemaNodeBuilder findUnknownNode(final String name, final Builder parent) {
+ for (UnknownSchemaNodeBuilder un : parent.getUnknownNodes()) {
+ if (un.getQName().getLocalName().equals(name)) {
+ return un;
+ }
+ }
+ return null;
+ }
+
/**
*
* Find a builder for node in data namespace of YANG module.
Optional<SchemaNodeBuilder> currentNode = getDataNamespaceChild(module, first);
while (currentNode.isPresent() && path.hasNext()) {
- currentNode = findDataChild(currentNode.get(), path.next());
+ SchemaNodeBuilder currentParent = currentNode.get();
+ QName currentPath = path.next();
+ currentNode = findDataChild(currentParent, currentPath);
+ if (!currentNode.isPresent()) {
+ for (SchemaNodeBuilder un : currentParent.getUnknownNodes()) {
+ if (un.getQName().equals(currentPath)) {
+ currentNode = Optional.of(un);
+ }
+ }
+ }
}
return currentNode;
}
return Optional.absent();
}
+ // FIXME: if rpc does not define input or output, this method creates it
/**
*
* Gets input / output container from {@link RpcDefinitionBuilder} if QName
* @return Optional of input/output if defined and QName is input/output.
* Otherwise {@link Optional#absent()}.
*/
- private static Optional<ContainerSchemaNodeBuilder> findContainerInRpc(final RpcDefinitionBuilder parent, final QName child) {
+ private static Optional<ContainerSchemaNodeBuilder> findContainerInRpc(final RpcDefinitionBuilder parent,
+ final QName child) {
if (INPUT.equals(child.getLocalName())) {
+ if (parent.getInput() == null) {
+ QName qname = QName.create(parent.getQName().getModule(), "input");
+ final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(parent.getModuleName(),
+ parent.getLine(), qname, parent.getPath().createChild(qname));
+ inputBuilder.setParent(parent);
+ parent.setInput(inputBuilder);
+ return Optional.of(inputBuilder);
+ }
return Optional.of(parent.getInput());
} else if (OUTPUT.equals(child.getLocalName())) {
+ if (parent.getOutput() == null) {
+ QName qname = QName.create(parent.getQName().getModule(), "output");
+ final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(parent.getModuleName(),
+ parent.getLine(), qname, parent.getPath().createChild(qname));
+ outputBuilder.setParent(parent);
+ parent.setOutput(outputBuilder);
+ return Optional.of(outputBuilder);
+ }
return Optional.of(parent.getOutput());
}
LOG.trace("Child {} not found in node {}", child, parent);
*/
public static boolean processAugmentation(final AugmentationSchemaBuilder augment,
final ModuleBuilder firstNodeParent) {
- Optional<SchemaNodeBuilder> potentialTargetNode = findSchemaNodeInModule(augment.getTargetNodeSchemaPath(),
+ Optional<SchemaNodeBuilder> potentialTargetNode = findSchemaNodeInModule(augment.getTargetPath(),
firstNodeParent);
if (!potentialTargetNode.isPresent()) {
return false;
+ } else if (potentialTargetNode.get() instanceof UnknownSchemaNodeBuilder) {
+ LOG.warn("Error in augment parsing: unsupported augment target: {}", potentialTargetNode.get());
+ return true;
}
SchemaNodeBuilder targetNode = potentialTargetNode.get();
fillAugmentTarget(augment, targetNode);
return true;
}
- public static IdentitySchemaNodeBuilder findBaseIdentity(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final String baseString, final int line) {
+ public static IdentitySchemaNodeBuilder findBaseIdentity(final ModuleBuilder module, final String baseString,
+ final int line) {
// FIXME: optimize indexOf() away?
if (baseString.indexOf(':') != -1) {
}
public static Set<DataSchemaNodeBuilder> wrapChildNodes(final String moduleName, final int line,
- final Set<DataSchemaNode> nodes, final SchemaPath parentPath, final QName parentQName) {
- Set<DataSchemaNodeBuilder> result = new HashSet<>();
+ final Collection<DataSchemaNode> nodes, final SchemaPath parentPath, final QName parentQName) {
+ Set<DataSchemaNodeBuilder> result = new LinkedHashSet<>(nodes.size());
for (DataSchemaNode node : nodes) {
QName qname = QName.create(parentQName, node.getQName().getLocalName());
}
}
+ public static ModuleBuilder findModule(final QName qname, final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ TreeMap<Date, ModuleBuilder> map = modules.get(qname.getNamespace());
+ if (map == null) {
+ return null;
+ }
+ if (qname.getRevision() == null) {
+ return map.lastEntry().getValue();
+ }
+ return map.get(qname.getRevision());
+ }
+
+ public static Map<String, TreeMap<Date, URI>> createYangNamespaceContext(
+ final Collection<? extends ParseTree> modules, final Optional<SchemaContext> context) {
+ Map<String, TreeMap<Date, URI>> map = new HashMap<>();
+ for (ParseTree module : modules) {
+ for (int i = 0; i < module.getChildCount(); i++) {
+ ParseTree moduleTree = module.getChild(i);
+ if (moduleTree instanceof Module_stmtContext) {
+ Module_stmtContext moduleCtx = (Module_stmtContext) moduleTree;
+ final String moduleName = ParserListenerUtils.stringFromNode(moduleCtx);
+ Date rev = null;
+ URI namespace = null;
+ for (int j = 0; j < moduleCtx.getChildCount(); j++) {
+ ParseTree moduleCtxChildTree = moduleCtx.getChild(j);
+ if (moduleCtxChildTree instanceof Revision_stmtsContext) {
+ String revisionDateStr = YangModelDependencyInfo
+ .getLatestRevision((Revision_stmtsContext) moduleCtxChildTree);
+ if (revisionDateStr == null) {
+ rev = new Date(0);
+ } else {
+ rev = QName.parseRevision(revisionDateStr);
+ }
+ }
+ if (moduleCtxChildTree instanceof Module_header_stmtsContext) {
+ Module_header_stmtsContext headerCtx = (Module_header_stmtsContext) moduleCtxChildTree;
+ for (int k = 0; k < headerCtx.getChildCount(); k++) {
+ ParseTree ctx = headerCtx.getChild(k);
+ if (ctx instanceof Namespace_stmtContext) {
+ final String namespaceStr = ParserListenerUtils.stringFromNode(ctx);
+ namespace = URI.create(namespaceStr);
+ break;
+ }
+ }
+ }
+ }
+ TreeMap<Date, URI> revToNs = map.get(moduleName);
+ if (revToNs == null) {
+ revToNs = new TreeMap<>();
+ revToNs.put(rev, namespace);
+ map.put(moduleName, revToNs);
+ }
+ revToNs.put(rev, namespace);
+ }
+ }
+ }
+ if (context.isPresent()) {
+ for (Module module : context.get().getModules()) {
+ TreeMap<Date, URI> revToNs = map.get(module.getName());
+ if (revToNs == null) {
+ revToNs = new TreeMap<>();
+ revToNs.put(module.getRevision(), module.getNamespace());
+ map.put(module.getName(), revToNs);
+ }
+ revToNs.put(module.getRevision(), module.getNamespace());
+ }
+ }
+ return map;
+ }
+
}
Code Review / yangtools.git / blobdiff