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; }
private Optional<ActionDefinition> findOrigAction(final DataNodeContainer parent, final ActionDefinition action) { for (UsesNode uses : parent.getUses()) { final GroupingDefinition grp = findUsedGrouping(uses); final Optional<ActionDefinition> found = grp.getActions().stream() .filter(act -> action.getQName().equals(act.getQName())).findFirst(); if (found.isPresent()) { final ActionDefinition result = found.get(); return result.isAddedByUses() ? findOrigAction(grp, result) : found; } } return Optional.empty(); }
/** * 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 ModuleContext context) { for (final UsesNode usesNode : node.getUses()) { for (final AugmentationSchemaNode augment : usesNode.getAugmentations()) { usesAugmentationToGenTypes(context, augment, usesNode, node); processUsesAugments(augment, context); } } }
Set<UsesNode> usesNodes = container.getUses(); ret.addAll(usesNodes);
Set<UsesNode> usesNodes = container.getUses(); ret.addAll(usesNodes);
if (isDependencyContainer(dataNodeContainer)) { UsesNode usesNode = dataNodeContainer.getUses().iterator().next(); for (SchemaNode refineNode : usesNode.getRefines().values()) {
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); } } }
/** * 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; }
private void emitDataNodeContainer(final DataNodeContainer input) { for (final TypeDefinition<?> typedef : input.getTypeDefinitions()) { emitTypedefNode(typedef); } for (final GroupingDefinition grouping : input.getGroupings()) { emitGrouping(grouping); } for (final DataSchemaNode child : input.getChildNodes()) { emitDataSchemaNode(child); } for (final UsesNode usesNode : input.getUses()) { emitUsesNode(usesNode); } }
for (final UsesNode usesNode : dataNodeContainer.getUses()) { if (usesNode.getGroupingPath() != null) { final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).toInstance();