private void emitUsesNode(final UsesNode usesNode) { if (super.emitUses && !usesNode.isAddedByUses() && !usesNode.isAugmenting()) { super.writer.startUsesNode(usesNode.getGroupingPath().getLastComponent()); /* * FIXME: BUG-2444: whenNode / *(ifFeatureNode ) statusNode // * Optional F : descriptionNode // Optional referenceNode // * Optional */ for (final Entry<SchemaPath, SchemaNode> refine : usesNode.getRefines().entrySet()) { emitRefine(refine); } for (final AugmentationSchemaNode aug : usesNode.getAugmentations()) { emitUsesAugmentNode(aug); } super.writer.endNode(); } }
private GroupingDefinition findUsedGrouping(final UsesNode uses) { final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, uses.getGroupingPath() .getPathFromRoot()); if (targetGrouping instanceof GroupingDefinition) { return (GroupingDefinition) targetGrouping; } throw new IllegalArgumentException("Failed to resolve used grouping for " + uses); }
Iterator<QName> pathFromRoot = uses.getGroupingPath().getPathFromRoot().iterator(); if (!pathFromRoot.hasNext() || !pathFromRoot.next().equals(ConfigConstants.RPC_CONTEXT_REF_GROUPING_QNAME)) { for (SchemaNode refinedNode : uses.getRefines().values()) { for (UnknownSchemaNode unknownSchemaNode : refinedNode .getUnknownSchemaNodes()) {
private void processUsesAugments(final DataNodeContainer node, final ModuleContext context) { for (final UsesNode usesNode : node.getUses()) { for (final AugmentationSchemaNode augment : usesNode.getAugmentations()) { usesAugmentationToGenTypes(context, augment, usesNode, node); processUsesAugments(augment, context); } } }
for (SchemaNode refineNode : usesNode.getRefines().values()) { LeafSchemaNode refine = (LeafSchemaNode) usesNode.getRefines().values().iterator().next();
private static boolean isDependencyContainer(final DataNodeContainer dataNodeContainer) { if(dataNodeContainer.getUses().size() != 1) { return false; } UsesNode onlyUses = dataNodeContainer.getUses().iterator().next(); if(onlyUses.getGroupingPath().getLastComponent().equals(ServiceRef.QNAME) == false) { return false; } return getChildNodeSizeWithoutUses(dataNodeContainer) == 0; }
public static CharSequence writeUsesNode(final UsesNode usesNode) { CharSequence _xblockexpression = null; Map<SchemaPath, SchemaNode> _refines = usesNode.getRefines(); boolean _isEmpty = _refines.isEmpty(); final boolean hasRefines = (!_isEmpty); StringConcatenation _builder = new StringConcatenation(); _builder.append("uses "); SchemaPath _groupingPath = usesNode.getGroupingPath(); Iterable<QName> _pathFromRoot = _groupingPath.getPathFromRoot(); QName _head = IterableExtensions.<QName>head(_pathFromRoot); Map<SchemaPath, SchemaNode> _refines_1 = usesNode.getRefines(); CharSequence _writeRefines = YangTemplate.writeRefines(_refines_1); _builder.append(_writeRefines, " ");
for (AugmentationSchemaNode augment : usesNode.getAugmentations()) { ret.addAll(getAllUsesNodes(augment));
/** * Find "proper" qname of unknown node in case it comes from a grouping */ private static QName findQNameFromGrouping(final DataNodeContainer subtree, final SchemaContext ctx, final UnknownSchemaNode unknownSchemaNode, final String localIdentityName) { QName identityQName = null; for (UsesNode usesNode : subtree.getUses()) { SchemaNode dataChildByName = SchemaContextUtil.findDataSchemaNode(ctx, usesNode.getGroupingPath()); Module m = SchemaContextUtil.findParentModule(ctx, dataChildByName); List<UnknownSchemaNode> unknownSchemaNodes = dataChildByName.getUnknownSchemaNodes(); if(Collections2.transform(unknownSchemaNodes, UNKNOWN_NODE_TO_STRING).contains(UNKNOWN_NODE_TO_STRING.apply(unknownSchemaNode))) { identityQName = QName.create(dataChildByName.getQName(), localIdentityName); } } return identityQName; }
private void processUsesAugments(final DataNodeContainer node, final Module module) { final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule()); for (final UsesNode usesNode : node.getUses()) { for (final AugmentationSchema augment : usesNode.getAugmentations()) { usesAugmentationToGenTypes(basePackageName, augment, module, usesNode, node); processUsesAugments(augment, module); } } }
final GeneratedTypeBuilder builder) { for (final UsesNode usesNode : dataNodeContainer.getUses()) { if (usesNode.getGroupingPath() != null) { final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).toInstance(); if (genType == null) { throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for " + builder.getName());
for (AugmentationSchema augment : usesNode.getAugmentations()) { ret.addAll(getAllUsesNodes(augment));
/** * Adds the implemented types to type builder. The method passes through the list of <i>uses</i> in * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding generated type * from {@link ModuleContext#groupings allGroupings} which is added as <i>implements type</i> * to <code>builder</code> * * @param dataNodeContainer element which contains the list of used YANG groupings * @param builder builder to which are added implemented types according to <code>dataNodeContainer</code> * @return generated type builder with all implemented types */ private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer, final GeneratedTypeBuilder builder) { for (final UsesNode usesNode : dataNodeContainer.getUses()) { final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).build(); if (genType == null) { throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for " + builder.getName()); } builder.addImplementsType(genType); } return builder; }
SchemaPath schemaPath = usesNode.getGroupingPath(); if (schemaPath != null) { Node nodeTo = nodeMap.get(schemaPath);
SchemaPath schemaPath = usesNode.getGroupingPath(); if (schemaPath != null) { Node nodeTo = nodeMap.get(schemaPath);
final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, parentUsesNode.getGroupingPath() .getPathFromRoot()); if (!(targetGrouping instanceof GroupingDefinition)) {