return path;
}
+ @Override
+ List<PathArgument> tryReversePathArguments() {
+ return path.reverse();
+ }
+
@Override
public PathArgument getLastPathArgument() {
return path.isEmpty()? null : path.get(path.size() - 1);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.api;
+
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+
+/*
+ * This base class provides binary backwards compatibility for Helium, which
+ * used an Iterable instead of collection.
+ *
+ * @deprecated remove this class in Beryllium
+ */
+@Deprecated
+abstract class IterablePathArguments {
+ public abstract Iterable<PathArgument> getPathArguments();
+ public abstract Iterable<PathArgument> getReversePathArguments();
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.api;
+
+import com.google.common.collect.UnmodifiableIterator;
+import java.util.AbstractCollection;
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+
+abstract class PathArgumentCollection extends AbstractCollection<PathArgument> {
+ @Override
+ public abstract UnmodifiableIterator<PathArgument> iterator();
+
+ @Override
+ public final boolean isEmpty() {
+ return false;
+ }
+
+ @Override
+ public final boolean remove(final Object o) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public final boolean addAll(final Collection<? extends PathArgument> c) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public final boolean removeAll(final Collection<?> c) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public final boolean retainAll(final Collection<?> c) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public final void clear() {
+ throw new UnsupportedOperationException();
+ }
+}
import java.util.List;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-final class StackedPathArguments implements Iterable<PathArgument> {
- private final List<StackedYangInstanceIdentifier> stack;
- private final YangInstanceIdentifier base;
+final class StackedPathArguments extends PathArgumentCollection {
+ private final Collection<PathArgument> base;
+ private final List<PathArgument> stack;
- public StackedPathArguments(final YangInstanceIdentifier base, final List<StackedYangInstanceIdentifier> stack) {
- this.base = Preconditions.checkNotNull(base);
+ public StackedPathArguments(final YangInstanceIdentifier base, final List<PathArgument> stack) {
+ this.base = base.getPathArguments();
this.stack = Preconditions.checkNotNull(stack);
}
@Override
- public Iterator<PathArgument> iterator() {
+ public int size() {
+ return stack.size() + base.size();
+ }
+
+ @Override
+ public boolean contains(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ return stack.contains(srch) || base.contains(srch);
+ }
+
+ @Override
+ public UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(base, stack);
}
private static final class IteratorImpl extends UnmodifiableIterator<PathArgument> {
- private final Iterator<StackedYangInstanceIdentifier> stack;
+ private final Iterator<PathArgument> stack;
private final Iterator<PathArgument> base;
- IteratorImpl(final YangInstanceIdentifier base, final Collection<StackedYangInstanceIdentifier> stack) {
- this.base = base.getPathArguments().iterator();
+ IteratorImpl(final Iterable<PathArgument> base, final Iterable<PathArgument> stack) {
+ this.base = base.iterator();
this.stack = stack.iterator();
}
if (base.hasNext()) {
return base.next();
}
- return stack.next().getLastPathArgument();
+ return stack.next();
}
}
}
package org.opendaylight.yangtools.yang.data.api;
import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
+import com.google.common.collect.Iterators;
import com.google.common.collect.UnmodifiableIterator;
+import java.util.Collection;
import java.util.Iterator;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-final class StackedReversePathArguments implements Iterable<PathArgument> {
+final class StackedReversePathArguments extends PathArgumentCollection {
private final StackedYangInstanceIdentifier identifier;
+ private int size;
+ private volatile boolean haveSize;
StackedReversePathArguments(final StackedYangInstanceIdentifier identifier) {
this.identifier = Preconditions.checkNotNull(identifier);
}
+ private static int calculateSize(final YangInstanceIdentifier parent) {
+ YangInstanceIdentifier current = parent;
+ for (int i = 1;; ++i) {
+ final Collection<PathArgument> args = current.tryReversePathArguments();
+ if (args != null) {
+ return i + args.size();
+ }
+
+ Verify.verify(current instanceof StackedYangInstanceIdentifier);
+ current = ((StackedYangInstanceIdentifier)current).getParent();
+ }
+ }
+
+ @Override
+ public int size() {
+ int ret = size;
+ if (!haveSize) {
+ ret = calculateSize(identifier.getParent());
+ size = ret;
+ haveSize = true;
+ }
+
+ return ret;
+ }
+
+
+ @Override
+ public boolean contains(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ return Iterators.contains(iterator(), srch);
+ }
+
@Override
- public Iterator<PathArgument> iterator() {
+ public
UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(identifier);
}
final PathArgument ret = identifier.getLastPathArgument();
final YangInstanceIdentifier next = identifier.getParent();
- if (!(next instanceof StackedYangInstanceIdentifier)) {
- tail = next.getReversePathArguments().iterator();
+ final Iterable<PathArgument> args = next.tryReversePathArguments();
+ if (args != null) {
+ tail = args.iterator();
identifier = null;
} else {
+ Verify.verify(next instanceof StackedYangInstanceIdentifier);
identifier = (StackedYangInstanceIdentifier) next;
}
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
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
Iterable<PathArgument> getPathArguments() {
- Iterable<PathArgument> ret = tryPathArguments();
+ public
Collection<PathArgument> getPathArguments() {
+ StackedPathArguments 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
Collection<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?
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
*
* @see <a href="http://tools.ietf.org/html/rfc6020#section-9.13">RFC6020</a>
*/
-public abstract class YangInstanceIdentifier implements Path<YangInstanceIdentifier>, Immutable, Serializable {
+public abstract class YangInstanceIdentifier extends IterablePathArguments implements Path<YangInstanceIdentifier>, Immutable, Serializable {
/**
* An empty {@link YangInstanceIdentifier}. It corresponds to the path of the conceptual
* root of the YANG namespace.
}
@Nonnull abstract YangInstanceIdentifier createRelativeIdentifier(int skipFromRoot);
- @Nonnull abstract Iterable<PathArgument> tryPathArguments();
+ @Nonnull abstract Collection<PathArgument> tryPathArguments();
+ @Nonnull abstract Collection<PathArgument> tryReversePathArguments();
/**
* Check if this instance identifier has empty path arguments, e.g. it is
*
* @return Immutable iteration of path arguments.
*/
- public abstract Iterable<PathArgument> getPathArguments();
+ @Override
+ public abstract Collection<PathArgument> getPathArguments();
/**
* Returns an iterable of path arguments in reverse order. This is useful
*
* @return Immutable iterable of path arguments in reverse order.
*/
- public abstract Iterable<PathArgument> getReversePathArguments();
+ @Override
+ public abstract Collection<PathArgument> getReversePathArguments();
/**
* Returns the last PathArgument. This is equivalent of iterating
Code Review / yangtools.git / commitdiff