import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
final class StackedYangInstanceIdentifier extends YangInstanceIdentifier {
private static final long serialVersionUID = 1L;
PARENT_FIELD = f;
}
- @SuppressWarnings("rawtypes")
- private static final AtomicReferenceFieldUpdater<StackedYangInstanceIdentifier, ImmutableList> LEGACYPATH_UPDATER =
- AtomicReferenceFieldUpdater.newUpdater(StackedYangInstanceIdentifier.class, ImmutableList.class, "legacyPath");
-
private final YangInstanceIdentifier parent;
private final PathArgument pathArgument;
- private transient volatile ImmutableList<PathArgument> legacyPath;
- private transient volatile Iterable<PathArgument> pathArguments;
- private transient volatile Iterable<PathArgument> reversePathArguments;
+ private transient volatile StackedPathArguments pathArguments;
+ private transient volatile StackedReversePathArguments reversePathArguments;
StackedYangInstanceIdentifier(final YangInstanceIdentifier parent, final PathArgument pathArgument, final int hash) {
super(hash);
}
@Override
- public List<PathArgument> getPath() {
- // Temporary variable saves a volatile read
- ImmutableList<PathArgument> ret = legacyPath;
+ public List<PathArgument> getPathArguments() {
+ StackedPathArguments ret = tryPathArguments();
if (ret == null) {
- // We could have used a synchronized block, but the window is quite
- // small and worst that can happen is duplicate object construction.
- ret = ImmutableList.copyOf(getPathArguments());
- LEGACYPATH_UPDATER.lazySet(this, ret);
- }
-
- return ret;
- }
-
- @Override
- public Iterable<PathArgument> getPathArguments() {
- Iterable<PathArgument> ret = tryPathArguments();
- if (ret == null) {
- List<StackedYangInstanceIdentifier> stack = new ArrayList<>();
+ List<PathArgument> stack = new ArrayList<>();
YangInstanceIdentifier current = this;
while (current.tryPathArguments() == null) {
Verify.verify(current instanceof StackedYangInstanceIdentifier);
final StackedYangInstanceIdentifier stacked = (StackedYangInstanceIdentifier) current;
- stack.add(stacked);
+ stack.add(stacked.getLastPathArgument());
current = stacked.getParent();
}
}
@Override
- public Iterable<PathArgument> getReversePathArguments() {
- Iterable<PathArgument> ret = reversePathArguments;
+ public List<PathArgument> getReversePathArguments() {
+ StackedReversePathArguments ret = tryReversePathArguments();
if (ret == null) {
ret = new StackedReversePathArguments(this);
reversePathArguments = ret;
}
@Override
- Iterable<PathArgument> tryPathArguments() {
+ StackedPathArguments tryPathArguments() {
return pathArguments;
}
+ @Override
+ StackedReversePathArguments tryReversePathArguments() {
+ return reversePathArguments;
+ }
+
@Override
YangInstanceIdentifier createRelativeIdentifier(final int skipFromRoot) {
// TODO: can we optimize this one?