--- /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 java.util.Collection;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+
+/**
+ * This class provides backwards compatibility with the previous switch to
+ * Collections.
+ *
+ * @deprecated Remove before Lithium ships
+ */
+@Deprecated
+abstract class CollectionPathArguments extends IterablePathArguments {
+ @Override
+ public abstract Collection<PathArgument> getPathArguments();
+ @Override
+ public abstract Collection<PathArgument> getReversePathArguments();
+}
return ret;
}
- @Override
- public List<PathArgument> getPath() {
- return path;
- }
-
@Override
public List<PathArgument> getPathArguments() {
return path;
package org.opendaylight.yangtools.yang.data.api;
import com.google.common.collect.UnmodifiableIterator;
-import java.util.AbstractCollection;
+import java.util.AbstractList;
import java.util.Collection;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-abstract class PathArgument
Collection extends AbstractCollection<PathArgument> {
+abstract class PathArgument
List extends AbstractList<PathArgument> {
@Override
public abstract UnmodifiableIterator<PathArgument> iterator();
public final void clear() {
throw new UnsupportedOperationException();
}
+
+ @Override
+ public final boolean addAll(final int index, final Collection<? extends PathArgument> c) {
+ throw new UnsupportedOperationException();
+ }
}
import com.google.common.base.Preconditions;
import com.google.common.collect.UnmodifiableIterator;
-import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-final class StackedPathArguments extends PathArgumentCollection {
- private final
Collection<PathArgument> base;
+final class StackedPathArguments extends PathArgumentList {
+ private final
List<PathArgument> base;
private final List<PathArgument> stack;
public StackedPathArguments(final YangInstanceIdentifier base, final List<PathArgument> stack) {
return stack.contains(srch) || base.contains(srch);
}
+ @Override
+ public final PathArgument get(final int index) {
+ if (index < base.size()) {
+ return base.get(index);
+ } else {
+ return stack.get(index - base.size());
+ }
+ }
+
+ @Override
+ public final int indexOf(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+
+ int ret = base.indexOf(srch);
+ if (ret == -1) {
+ ret = stack.indexOf(srch);
+ if (ret != -1) {
+ return base.size() + ret;
+ }
+ }
+ return ret;
+ }
+
+ @Override
+ public final int lastIndexOf(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+
+ final int ret = stack.lastIndexOf(srch);
+ if (ret != -1) {
+ return base.size() + ret;
+ }
+
+ return base.lastIndexOf(srch);
+ }
+
@Override
public UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(base, stack);
import java.util.Iterator;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-final class StackedReversePathArguments extends PathArgumentCollection {
+final class StackedReversePathArguments extends PathArgumentList {
private final StackedYangInstanceIdentifier identifier;
private int size;
private volatile boolean haveSize;
return Iterators.contains(iterator(), srch);
}
+ @Override
+ public PathArgument get(final int index) {
+ return Iterators.get(iterator(), index);
+ }
+
+ @Override
+ public int indexOf(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ return super.indexOf(srch);
+ }
+
+ @Override
+ public int lastIndexOf(final Object o) {
+ final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+
+ int ret = -1;
+ final Iterator<PathArgument> it = iterator();
+ for (int i = 0; it.hasNext(); ++i) {
+ if (srch.equals(it.next())) {
+ ret = i;
+ }
+ }
+
+ return ret;
+ }
+
@Override
public UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(identifier);
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.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;
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 StackedPathArguments pathArguments;
private transient volatile StackedReversePathArguments reversePathArguments;
}
@Override
- public List<PathArgument> getPath() {
- // Temporary variable saves a volatile read
- ImmutableList<PathArgument> ret = legacyPath;
- 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 Collection<PathArgument> getPathArguments() {
+ public List<PathArgument> getPathArguments() {
StackedPathArguments ret = tryPathArguments();
if (ret == null) {
List<PathArgument> stack = new ArrayList<>();
}
@Override
- public
Collection<PathArgument> getReversePathArguments() {
+ public
List<PathArgument> getReversePathArguments() {
StackedReversePathArguments ret = tryReversePathArguments();
if (ret == null) {
ret = new StackedReversePathArguments(this);
*
* @see <a href="http://tools.ietf.org/html/rfc6020#section-9.13">RFC6020</a>
*/
-public abstract class YangInstanceIdentifier extends IterablePathArguments implements Path<YangInstanceIdentifier>, Immutable, Serializable {
+public abstract class YangInstanceIdentifier extends CollectionPathArguments implements Path<YangInstanceIdentifier>, Immutable, Serializable {
/**
* An empty {@link YangInstanceIdentifier}. It corresponds to the path of the conceptual
* root of the YANG namespace.
* @return Immutable list of path arguments.
*/
@Deprecated
- public abstract List<PathArgument> getPath();
+ public final List<PathArgument> getPath() {
+ return getPathArguments();
+ }
/**
* Returns an ordered iteration of path arguments.
* @return Immutable iteration of path arguments.
*/
@Override
- public abstract
Collection<PathArgument> getPathArguments();
+ public abstract
List<PathArgument> getPathArguments();
/**
* Returns an iterable of path arguments in reverse order. This is useful
* @return Immutable iterable of path arguments in reverse order.
*/
@Override
- public abstract
Collection<PathArgument> getReversePathArguments();
+ public abstract
List<PathArgument> getReversePathArguments();
/**
* Returns the last PathArgument. This is equivalent of iterating
Code Review / yangtools.git / commitdiff