2 * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.data.impl.schema.tree;
10 import static com.google.common.base.Preconditions.checkState;
11 import static com.google.common.base.Verify.verify;
12 import static java.util.Objects.requireNonNull;
14 import com.google.common.base.MoreObjects;
15 import com.google.common.collect.Collections2;
16 import com.google.common.collect.ImmutableList;
17 import com.google.common.collect.ImmutableSet;
18 import com.google.common.collect.Maps;
19 import java.util.Collections;
20 import java.util.Iterator;
21 import java.util.List;
23 import java.util.Optional;
25 import org.eclipse.jdt.annotation.NonNull;
26 import org.eclipse.jdt.annotation.Nullable;
27 import org.opendaylight.yangtools.concepts.Immutable;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
29 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
30 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
32 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
33 import org.slf4j.Logger;
34 import org.slf4j.LoggerFactory;
37 * A validator for a single {@code unique} constraint. This class is further specialized for single- and
38 * multiple-constraint implementations.
41 * The basic idea is that for each list entry there is a corresponding value vector of one or more values, each
42 * corresponding to one component of the {@code unique} constraint.
44 abstract class UniqueValidator<T> implements Immutable {
45 private static final class One extends UniqueValidator<Object> {
46 One(final List<NodeIdentifier> path) {
47 super(encodePath(path));
51 Object extractValues(final Map<List<NodeIdentifier>, Object> valueCache, final DataContainerNode<?> data) {
52 return extractValue(valueCache, data, decodePath(descendants));
56 Map<Descendant, @Nullable Object> indexValues(final Object values) {
57 return Collections.singletonMap(decodeDescendant(descendants), values);
61 private static final class Many extends UniqueValidator<Set<Object>> {
62 Many(final List<List<NodeIdentifier>> descendantPaths) {
63 super(descendantPaths.stream().map(UniqueValidator::encodePath).collect(ImmutableSet.toImmutableSet()));
67 UniqueValues extractValues(final Map<List<NodeIdentifier>, Object> valueCache,
68 final DataContainerNode<?> data) {
69 return descendants.stream()
70 .map(obj -> extractValue(valueCache, data, decodePath(obj)))
71 .collect(UniqueValues.COLLECTOR);
75 Map<Descendant, @Nullable Object> indexValues(final Object values) {
76 final Map<Descendant, @Nullable Object> index = Maps.newHashMapWithExpectedSize(descendants.size());
77 final Iterator<?> it = ((UniqueValues) values).iterator();
78 for (Object obj : descendants) {
79 verify(index.put(decodeDescendant(obj), it.next()) == null);
85 private static final Logger LOG = LoggerFactory.getLogger(UniqueValidator.class);
87 final @NonNull T descendants;
89 UniqueValidator(final T descendants) {
90 this.descendants = requireNonNull(descendants);
93 static UniqueValidator<?> of(final List<List<NodeIdentifier>> descendants) {
94 return descendants.size() == 1 ? new One(descendants.get(0)) : new Many(descendants);
98 * Extract a value vector from a particular child.
100 * @param valueCache Cache of descendants already looked up
101 * @param data Root data node
102 * @return Value vector
104 abstract @Nullable Object extractValues(Map<List<NodeIdentifier>, Object> valueCache,
105 DataContainerNode<?> data);
108 * Index a value vector by associating each value with its corresponding {@link Descendant}.
110 * @param values Value vector
111 * @return Map of Descandant/value relations
113 abstract Map<Descendant, @Nullable Object> indexValues(Object values);
116 * Encode a path for storage. Single-element paths are squashed to their only element. The inverse operation is
117 * {@link #decodePath(Object)}.
119 * @param path Path to encode
120 * @return Encoded path.
122 static final Object encodePath(final List<NodeIdentifier> path) {
123 return path.size() == 1 ? path.get(0) : ImmutableList.copyOf(path);
127 * Decode a path from storage. This is the inverse operation to {@link #encodePath(List)}.
129 * @param obj Encoded path
130 * @return Decoded path
132 static final @NonNull ImmutableList<NodeIdentifier> decodePath(final Object obj) {
133 return obj instanceof NodeIdentifier ? ImmutableList.of((NodeIdentifier) obj)
134 : (ImmutableList<NodeIdentifier>) obj;
137 static final @NonNull Descendant decodeDescendant(final Object obj) {
138 return Descendant.of(Collections2.transform(decodePath(obj), NodeIdentifier::getNodeType));
142 * Extract the value for a single descendant.
144 * @param valueCache Cache of descendants already looked up
145 * @param data Root data node
146 * @param path Descendant path
147 * @return Value for the descendant
149 static final @Nullable Object extractValue(final Map<List<NodeIdentifier>, Object> valueCache,
150 final DataContainerNode<?> data, final List<NodeIdentifier> path) {
151 return valueCache.computeIfAbsent(path, key -> extractValue(data, key));
155 * Extract the value for a single descendant.
157 * @param data Root data node
158 * @param path Descendant path
159 * @return Value for the descendant
161 private static @Nullable Object extractValue(final DataContainerNode<?> data, final List<NodeIdentifier> path) {
162 DataContainerNode<?> current = data;
163 final Iterator<NodeIdentifier> it = path.iterator();
165 final NodeIdentifier step = it.next();
166 final Optional<DataContainerChild<?, ?>> optNext = current.getChild(step);
167 if (optNext.isEmpty()) {
171 final DataContainerChild<?, ?> next = optNext.orElseThrow();
173 checkState(next instanceof LeafNode, "Unexpected node %s at %s", next, path);
174 final Object value = next.getValue();
175 LOG.trace("Resolved {} to value {}", path, value);
179 checkState(next instanceof DataContainerNode, "Unexpected node %s in %s", next, path);
180 current = (DataContainerNode<?>) next;
185 public final String toString() {
186 return MoreObjects.toStringHelper(this).add("paths", descendants).toString();