data/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/StackedYangInstanceIdentifier.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. 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.api;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Verify.verify;
  12 import static com.google.common.base.Verify.verifyNotNull;
  13 import static java.util.Objects.requireNonNull;
  14
  15 import com.google.common.collect.Iterables;
  16 import com.google.common.collect.Lists;
  17 import java.io.IOException;
  18 import java.io.ObjectInputStream;
  19 import java.io.ObjectOutputStream;
  20 import java.lang.reflect.Field;
  21 import java.security.AccessController;
  22 import java.security.PrivilegedAction;
  23 import java.util.ArrayList;
  24 import java.util.List;
  25 import org.eclipse.jdt.annotation.NonNull;
  26
  27 final class StackedYangInstanceIdentifier extends YangInstanceIdentifier implements Cloneable {
  28     private static final long serialVersionUID = 1L;
  29     private static final Field PARENT_FIELD;
  30
  31     static {
  32         final Field f;
  33         try {
  34             f = StackedYangInstanceIdentifier.class.getDeclaredField("parent");
  35         } catch (NoSuchFieldException | SecurityException e) {
  36             throw new ExceptionInInitializerError(e);
  37         }
  38
  39         AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
  40             f.setAccessible(true);
  41             return null;
  42         });
  43
  44         PARENT_FIELD = f;
  45     }
  46
  47     private final @NonNull YangInstanceIdentifier parent;
  48     private final @NonNull PathArgument pathArgument;
  49
  50     private transient volatile StackedPathArguments pathArguments;
  51     private transient volatile StackedReversePathArguments reversePathArguments;
  52
  53     StackedYangInstanceIdentifier(final YangInstanceIdentifier parent, final PathArgument pathArgument,
  54             final int hash) {
  55         super(hash);
  56         this.parent = requireNonNull(parent);
  57         this.pathArgument = requireNonNull(pathArgument);
  58     }
  59
  60     @Override
  61     public StackedYangInstanceIdentifier clone() {
  62         try {
  63             return (StackedYangInstanceIdentifier) super.clone();
  64         } catch (CloneNotSupportedException e) {
  65             throw new IllegalStateException("clone() should be supported", e);
  66         }
  67     }
  68
  69     @Override
  70     public @NonNull YangInstanceIdentifier getParent() {
  71         return parent;
  72     }
  73
  74     @Override
  75     public YangInstanceIdentifier coerceParent() {
  76         return parent;
  77     }
  78
  79     @Override
  80     public YangInstanceIdentifier getAncestor(final int depth) {
  81         checkArgument(depth >= 0, "Steps cannot be negative");
  82
  83         // Calculate how far up our FixedYangInstanceIdentifier ancestor is
  84         int stackedDepth = 1;
  85         YangInstanceIdentifier wlk = getParent();
  86         while (wlk instanceof StackedYangInstanceIdentifier) {
  87             wlk = wlk.getParent();
  88             stackedDepth++;
  89         }
  90
  91         // Guaranteed to come from FixedYangInstanceIdentifier
  92         final int fixedDepth = wlk.getPathArguments().size();
  93         if (fixedDepth >= depth) {
  94             return wlk.getAncestor(depth);
  95         }
  96
  97         // Calculate our depth and check argument
  98         final int ourDepth = stackedDepth + fixedDepth;
  99         checkArgument(depth <= ourDepth, "Depth %s exceeds maximum depth %s", depth, ourDepth);
 100
 101         // Requested depth is covered by the stack, traverse up for specified number of steps
 102         final int toWalk = ourDepth - depth;
 103         YangInstanceIdentifier result = this;
 104         for (int i = 0; i < toWalk; ++i) {
 105             result = verifyNotNull(result.getParent());
 106         }
 107
 108         return result;
 109     }
 110
 111     @Override
 112     public boolean isEmpty() {
 113         return false;
 114     }
 115
 116     @Override
 117     public List<PathArgument> getPathArguments() {
 118         StackedPathArguments ret = tryPathArguments();
 119         if (ret == null) {
 120             final List<PathArgument> stack = new ArrayList<>();
 121             YangInstanceIdentifier current = this;
 122             do {
 123                 verify(current instanceof StackedYangInstanceIdentifier);
 124                 final StackedYangInstanceIdentifier stacked = (StackedYangInstanceIdentifier) current;
 125                 stack.add(stacked.getLastPathArgument());
 126                 current = stacked.getParent();
 127             } while (current.tryPathArguments() == null);
 128
 129             ret = new StackedPathArguments(current, Lists.reverse(stack));
 130             pathArguments = ret;
 131         }
 132
 133         return ret;
 134     }
 135
 136     @Override
 137     public List<PathArgument> getReversePathArguments() {
 138         StackedReversePathArguments ret = tryReversePathArguments();
 139         if (ret == null) {
 140             ret = new StackedReversePathArguments(this);
 141             reversePathArguments = ret;
 142         }
 143         return ret;
 144     }
 145
 146     @Override
 147     public PathArgument getLastPathArgument() {
 148         return pathArgument;
 149     }
 150
 151     @Override
 152     StackedPathArguments tryPathArguments() {
 153         return pathArguments;
 154     }
 155
 156     @Override
 157     StackedReversePathArguments tryReversePathArguments() {
 158         return reversePathArguments;
 159     }
 160
 161     @Override
 162     YangInstanceIdentifier createRelativeIdentifier(final int skipFromRoot) {
 163         // TODO: can we optimize this one?
 164         return YangInstanceIdentifier.create(Iterables.skip(getPathArguments(), skipFromRoot));
 165     }
 166
 167     @Override
 168     boolean pathArgumentsEqual(final YangInstanceIdentifier other) {
 169         if (other instanceof StackedYangInstanceIdentifier) {
 170             final StackedYangInstanceIdentifier stacked = (StackedYangInstanceIdentifier) other;
 171             return pathArgument.equals(stacked.pathArgument) && parent.equals(stacked.parent);
 172         }
 173         return super.pathArgumentsEqual(other);
 174     }
 175
 176     private void readObject(final ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
 177         inputStream.defaultReadObject();
 178
 179         final FixedYangInstanceIdentifier p = (FixedYangInstanceIdentifier) inputStream.readObject();
 180         try {
 181             PARENT_FIELD.set(this, p);
 182         } catch (IllegalArgumentException | IllegalAccessException e) {
 183             throw new IOException("Failed to set parent", e);
 184         }
 185     }
 186
 187     private void writeObject(final ObjectOutputStream outputStream) throws IOException {
 188         outputStream.defaultWriteObject();
 189
 190         final FixedYangInstanceIdentifier p;
 191         if (parent instanceof FixedYangInstanceIdentifier) {
 192             p = (FixedYangInstanceIdentifier) parent;
 193         } else {
 194             p = FixedYangInstanceIdentifier.create(parent.getPathArguments(), parent.hashCode());
 195         }
 196         outputStream.writeObject(p);
 197     }
 198
 199     @Override
 200     public YangInstanceIdentifier toOptimized() {
 201         return FixedYangInstanceIdentifier.create(getPathArguments());
 202     }
 203 }