yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/NormalizedNodeContainerSupport.java

   1 /*
   2  * Copyright (c) 2019 Pantheon Technologies, s.r.o. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.yangtools.yang.data.impl.schema.tree;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.base.MoreObjects;
  14 import java.util.function.Function;
  15 import java.util.function.Supplier;
  16 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  17 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  18 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  19 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  20 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
  21 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
  22
  23 abstract class NormalizedNodeContainerSupport<K extends PathArgument, T extends NormalizedNode<K, ?>> {
  24     static final class Single<K extends PathArgument, T extends NormalizedNode<K, ?>>
  25             extends NormalizedNodeContainerSupport<K, T> {
  26         Single(final Class<T> requiredClass,
  27                 final Function<T, NormalizedNodeContainerBuilder<K, ?, ?, T>> copyBuilder,
  28                 final Supplier<NormalizedNodeContainerBuilder<K, ?, ?, T>> emptyBuilder) {
  29             this(requiredClass, ChildTrackingPolicy.UNORDERED, copyBuilder, emptyBuilder);
  30         }
  31
  32         Single(final Class<T> requiredClass, final ChildTrackingPolicy childPolicy,
  33                 final Function<T, NormalizedNodeContainerBuilder<K, ?, ?, T>> copyBuilder,
  34                 final Supplier<NormalizedNodeContainerBuilder<K, ?, ?, T>> emptyBuilder) {
  35             super(requiredClass, childPolicy, copyBuilder, emptyBuilder);
  36         }
  37
  38         @Override
  39         NormalizedNodeContainerBuilder<?, ?, ?, T> createBuilder(final NormalizedNode<?, ?> original) {
  40             return copyBuilder.apply(cast(original));
  41         }
  42
  43         @Override
  44         NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) {
  45             return emptyBuilder.get().withNodeIdentifier(cast(original).getIdentifier()).build();
  46         }
  47
  48         private T cast(final NormalizedNode<?, ?> original) {
  49             checkArgument(requiredClass.isInstance(original), "Require %s, got %s", requiredClass, original);
  50             return requiredClass.cast(original);
  51         }
  52     }
  53
  54     // FIXME: MapEntry a refactor of a hack, originally introduced in
  55     //        Change-Id: I9dc02a1917f38e8a0d62279843974b9869c48693. DataTreeRoot needs to be fixed up to properly
  56     //        handle the lookup of through maps.
  57     static final class MapEntry<T extends NormalizedNode<NodeIdentifier, ?>>
  58             extends NormalizedNodeContainerSupport<NodeIdentifier, T> {
  59         MapEntry(final Class<T> requiredClass, final ChildTrackingPolicy childPolicy,
  60                 final Function<T, NormalizedNodeContainerBuilder<NodeIdentifier, ?, ?, T>> copyBuilder,
  61                 final Supplier<NormalizedNodeContainerBuilder<NodeIdentifier, ?, ?, T>> emptyBuilder) {
  62             super(requiredClass, childPolicy, copyBuilder, emptyBuilder);
  63         }
  64
  65         @Override
  66         NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final NormalizedNode<?, ?> original) {
  67             if (requiredClass.isInstance(original)) {
  68                 return copyBuilder.apply(requiredClass.cast(original));
  69             }
  70             if (original instanceof MapEntryNode) {
  71                 return ImmutableMapEntryNodeBuilder.create((MapEntryNode) original);
  72             }
  73             throw new IllegalArgumentException("Expected either MapEntryNode or " + requiredClass + ", offending node: "
  74                     + original);
  75         }
  76
  77         @Override
  78         NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) {
  79             if (requiredClass.isInstance(original)) {
  80                 return emptyBuilder.get().withNodeIdentifier(requiredClass.cast(original).getIdentifier()).build();
  81             }
  82             if (original instanceof MapEntryNode) {
  83                 return ImmutableMapEntryNodeBuilder.create()
  84                         .withNodeIdentifier(((MapEntryNode) original).getIdentifier()).build();
  85             }
  86             throw new IllegalArgumentException("Expected either MapEntryNode or " + requiredClass + ", offending node: "
  87                     + original);
  88         }
  89     }
  90
  91     final Function<T, NormalizedNodeContainerBuilder<K, ?, ?, T>> copyBuilder;
  92     final Supplier<NormalizedNodeContainerBuilder<K, ?, ?, T>> emptyBuilder;
  93     final ChildTrackingPolicy childPolicy;
  94     final Class<T> requiredClass;
  95
  96     NormalizedNodeContainerSupport(final Class<T> requiredClass, final ChildTrackingPolicy childPolicy,
  97             final Function<T, NormalizedNodeContainerBuilder<K, ?, ?, T>> copyBuilder,
  98             final Supplier<NormalizedNodeContainerBuilder<K, ?, ?, T>> emptyBuilder) {
  99         this.requiredClass = requireNonNull(requiredClass);
 100         this.childPolicy = requireNonNull(childPolicy);
 101         this.copyBuilder = requireNonNull(copyBuilder);
 102         this.emptyBuilder = requireNonNull(emptyBuilder);
 103     }
 104
 105     @SuppressWarnings("rawtypes")
 106     abstract NormalizedNodeContainerBuilder createBuilder(NormalizedNode<?, ?> original);
 107
 108     abstract NormalizedNode<?, ?> createEmptyValue(NormalizedNode<?, ?> original);
 109
 110     @Override
 111     public final String toString() {
 112         return MoreObjects.toStringHelper(this).add("requiredClass", requiredClass).toString();
 113     }
 114 }