private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) { final List<QName> keyDefinition = potential.getKeyDefinition(); if (keyDefinition == null || keyDefinition.isEmpty()) { return new UnkeyedListMixinNormalization(potential); } if (potential.isUserOrdered()) { return new OrderedMapMixinNormalization(potential); } return new UnorderedMapMixinNormalization(potential); }
@Override protected QName getQName(ListSchemaNode schema) { return schema.getQName(); }
public static ListAttribute create(ListSchemaNode node, TypeProviderWrapper typeProvider, String packageName) { TOAttribute innerAttribute = TOAttribute.create(node, typeProvider, packageName); return new ListAttribute(node, innerAttribute, node.getDescription()); }
private void emitList(final ListSchemaNode child) { super.writer.startListNode(child.getQName()); child.getWhenCondition().ifPresent(this::emitWhen); // FIXME: BUG-2444: *(ifFeatureNode ) child.getMustConstraints().forEach(this::emitMust); emitKey(child.getKeyDefinition()); emitUniqueConstraints(child.getUniqueConstraints()); emitConfigNode(child.isConfiguration()); child.getElementCountConstraint().ifPresent(this::emitCountConstraint); emitOrderedBy(child.isUserOrdered()); emitDocumentedNode(child); emitDataNodeContainer(child); emitUnknownStatementNodes(child.getUnknownSchemaNodes()); emitNotifications(child.getNotifications()); emitActions(child.getActions()); super.writer.endNode(); }
/** * Build map entry node identifier from schema and provided children. */ private NodeIdentifierWithPredicates constructNodeIdentifier() { final Map<QName, Object> predicates; final Collection<QName> keys = schema.getKeyDefinition(); if (!keys.isEmpty()) { predicates = keyDefToPredicates(keys); } else if (!childrenQNamesToPaths.isEmpty()) { predicates = childrenToPredicates(); } else { predicates = ImmutableMap.of(); } return new NodeIdentifierWithPredicates(schema.getQName(), predicates); }
@Override NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema) { // We assume there's only one key for the list. List<QName> keys = ((ListSchemaNode)dataSchema).getKeyDefinition(); Preconditions.checkArgument(keys.size() == 1, "Expected only 1 key for list %s", appConfigBindingClass); QName listKeyQName = keys.iterator().next(); return ImmutableNodes.mapEntryBuilder(bindingQName, listKeyQName, appConfigListKeyValue).build(); }
@VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } }
public static CharSequence writeListSchemaNode(final ListSchemaNode listSchemaNode) { StringConcatenation _builder = new StringConcatenation(); _builder.append("list "); QName _qName = listSchemaNode.getQName(); String _localName = _qName.getLocalName(); _builder.append(_localName, ""); List<QName> _keyDefinition = listSchemaNode.getKeyDefinition(); boolean _hasElements = false; for(final QName listKey : _keyDefinition) { Collection<DataSchemaNode> _childNodes = listSchemaNode.getChildNodes(); boolean _isNullOrEmpty = IterableExtensions.isNullOrEmpty(_childNodes); boolean _not = (!_isNullOrEmpty); if (_not) { _builder.append(" "); Collection<DataSchemaNode> _childNodes_1 = listSchemaNode.getChildNodes(); CharSequence _writeDataSchemaNodes = YangTemplate.writeDataSchemaNodes(_childNodes_1); _builder.append(_writeDataSchemaNodes, " "); Set<AugmentationSchema> _availableAugmentations = listSchemaNode.getAvailableAugmentations(); boolean _isNullOrEmpty_1 = IterableExtensions.isNullOrEmpty(_availableAugmentations); boolean _not_1 = (!_isNullOrEmpty_1); if (_not_1) { _builder.append(" "); Set<AugmentationSchema> _availableAugmentations_1 = listSchemaNode.getAvailableAugmentations(); CharSequence _writeAugments = YangTemplate.writeAugments(_availableAugmentations_1); _builder.append(_writeAugments, " "); Set<GroupingDefinition> _groupings = listSchemaNode.getGroupings();
/** * Generates for the <code>list</code> which contains any list keys special generated TO builder. * * @param packageName string with package name to which the list belongs * @param list list schema node which is source of data about the list name * @return generated TO builder which represents the keys of the <code>list</code> or null if <code>list</code> is * null or list of key definitions is null or empty. */ private GeneratedTOBuilder resolveListKeyTOBuilder(final ModuleContext context, final ListSchemaNode list) { if (list.getKeyDefinition() != null && !list.getKeyDefinition().isEmpty()) { return typeProvider.newGeneratedTOBuilder(JavaTypeName.create( packageNameForGeneratedType(context.modulePackageName(), list.getPath()), BindingMapping.getClassName(list.getQName().getLocalName() + "Key"))); } return null; }
if ((targetNode instanceof ListSchemaNode)) { final ListSchemaNode listNode = ((ListSchemaNode) targetNode); final int keysSize = listNode.getKeyDefinition().size(); if ((strings.size() - consumed) < keysSize) { throw new RestconfDocumentedException("Missing key for list \"" + listNode.getQName().getLocalName() + "\".", ErrorType.PROTOCOL, ErrorTag.DATA_MISSING); final HashMap<QName, Object> keyValues = new HashMap<QName, Object>(); int i = 0; for (final QName key : listNode.getKeyDefinition()) { + listNode.getQName().getLocalName() + "\" cannot contain \"null\" value as a key.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE); addKeyValue(keyValues, listNode.getDataChildByName(key), uriKeyValue, mountPoint); i++;
builder.append('/'); final List<QName> keyDefinition = node.getKeyDefinition(); boolean hasElements = false; for (final QName key : keyDefinition) { for (final DataSchemaNode listChild : node.getChildNodes()) { if (listChild.getQName().equals(key)) { if (!hasElements) {
private void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ListSchemaNode node) { final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node); if (genType != null) { constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), Types.listTypeFor(genType)); final List<String> listKeys = listKeys(node); final String packageName = packageNameForGeneratedType(basePackageName, node.getPath()); final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node); if (genTOBuilder != null) { final Type identifierMarker = Types.parameterizedTypeFor(IDENTIFIER, genType); final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder); genTOBuilder.addImplementsType(identifierMarker); genType.addImplementsType(identifiableMarker); } for (final DataSchemaNode schemaNode : node.getChildNodes()) { if (!schemaNode.isAugmenting()) { addSchemaNodeToListBuilders(basePackageName, schemaNode, genType, genTOBuilder, listKeys, module); } } // serialVersionUID if (genTOBuilder != null) { final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID"); prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder))); genTOBuilder.setSUID(prop); } typeBuildersToGenTypes(module, genType, genTOBuilder); } }
private static void constructNonnull(final GeneratedTypeBuilder interfaceBuilder, final Type returnType, final ListSchemaNode node) { final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod( BindingMapping.getNonnullMethodName(node.getQName().getLocalName())); getMethod.setReturnType(returnType).setDefault(true); annotateDeprecatedIfNecessary(node.getStatus(), getMethod); }
/** * This method creates an empty list container of a particular type. * * @deprecated This method is not generally useful, as empty lists do not convey information in YANG (they are * equivalent to non-present lists). It also leaks implementation details to a broader scope and should * never have been public in the first place. */ @Deprecated public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier parentMapPath) { final BindingCodecTreeNode<?> mapCodec = requireNonNull( codecRegistry.getCodecContext().getSubtreeCodec(parentMapPath), "Codec not found for yang instance identifier: " + parentMapPath); final WithStatus schema = mapCodec.getSchema(); if (schema instanceof ListSchemaNode) { final ListSchemaNode castedSchema = (ListSchemaNode) schema; return castedSchema.isUserOrdered() ? Builders.orderedMapBuilder(castedSchema).build() : Builders.mapBuilder(castedSchema).build(); } throw new IllegalArgumentException("Path does not point to list schema node"); }
private Object getValue(QName key, String value){ if(listSchemaNode != null){ for(DataSchemaNode node : listSchemaNode.getChildNodes()){ if(node instanceof LeafSchemaNode && node.getQName().equals(key)){ return TypeDefinitionAwareCodec.from(LeafSchemaNode.class.cast(node).getType()).deserialize(value); } } } return value; } }
/** * Selects the names of the list keys from <code>list</code> and returns them as the list of the strings. * * @param list of string with names of the list keys * @return list of string which represents names of the list keys. If the <code>list</code> contains no keys then * an empty list is returned. */ private static List<String> listKeys(final ListSchemaNode list) { final List<String> listKeys = new ArrayList<>(); final List<QName> keyDefinition = list.getKeyDefinition(); if (keyDefinition != null) { for (final QName keyDef : keyDefinition) { listKeys.add(keyDef.getLocalName()); } } return listKeys; }
/** * Generates for the <code>list</code> which contains any list keys special * generated TO builder. * * @param packageName * string with package name to which the list belongs * @param list * list schema node which is source of data about the list name * @return generated TO builder which represents the keys of the * <code>list</code> or null if <code>list</code> is null or list of * key definitions is null or empty. */ private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) { GeneratedTOBuilder genTOBuilder = null; if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) { final String listName = list.getQName().getLocalName() + "Key"; final String genTOName = BindingMapping.getClassName(listName); genTOBuilder = new GeneratedTOBuilderImpl(packageName, genTOName); } return genTOBuilder; }
/** * Get default DOM object on path for list. * * @param parentMapPath * - path * @return specific DOM object */ public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier parentMapPath) { final BindingTreeNodeCodec<?> mapCodec = codecRegistry.getCodecContext().getSubtreeCodec(parentMapPath); final Object schema = mapCodec.getSchema(); if (schema instanceof ListSchemaNode) { final ListSchemaNode castedSchema = (ListSchemaNode) schema; if (castedSchema.isUserOrdered()) { return Builders.orderedMapBuilder(castedSchema).build(); } else { return Builders.mapBuilder(castedSchema).build(); } } throw new IllegalArgumentException("Path does not point to list schema node"); }
private void listToGenType(final ModuleContext context, final GeneratedTypeBuilder parent, final Type baseInterface, final ListSchemaNode node) { final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node); if (genType != null) { final ParameterizedType listType = listTypeFor(genType); constructGetter(parent, listType, node); constructNonnull(parent, listType, node); final List<String> listKeys = listKeys(node); final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(context, node); if (genTOBuilder != null) { final Type identifierMarker = identifier(genType); final Type identifiableMarker = identifiable(genTOBuilder); genTOBuilder.addImplementsType(identifierMarker); genType.addImplementsType(identifiableMarker); } actionsToGenType(context, genType, node, genTOBuilder); for (final DataSchemaNode schemaNode : node.getChildNodes()) { if (!schemaNode.isAugmenting()) { addSchemaNodeToListBuilders(context, schemaNode, genType, genTOBuilder, listKeys); } } // serialVersionUID if (genTOBuilder != null) { final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID"); prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder))); genTOBuilder.setSUID(prop); } typeBuildersToGenTypes(context, genType, genTOBuilder); } }
IdentifiableItemCodec(final ListSchemaNode schema, final Class<? extends Identifier<?>> keyClass, final Class<?> identifiable) { this.identifiable = requireNonNull(identifiable); this.qname = schema.getQName(); }