yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/StackedReversePathArguments.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 com.google.common.base.Preconditions;
  11 import com.google.common.base.Verify;
  12 import com.google.common.collect.Iterators;
  13 import com.google.common.collect.UnmodifiableIterator;
  14 import java.util.Collection;
  15 import java.util.Iterator;
  16 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  17
  18 final class StackedReversePathArguments extends PathArgumentList {
  19     private final StackedYangInstanceIdentifier identifier;
  20     private int size;
  21     private volatile boolean haveSize;
  22
  23     StackedReversePathArguments(final StackedYangInstanceIdentifier identifier) {
  24         this.identifier = Preconditions.checkNotNull(identifier);
  25     }
  26
  27     private static int calculateSize(final YangInstanceIdentifier parent) {
  28         YangInstanceIdentifier current = parent;
  29         for (int i = 1;; ++i) {
  30             final Collection<PathArgument> args = current.tryReversePathArguments();
  31             if (args != null) {
  32                 return i + args.size();
  33             }
  34
  35             Verify.verify(current instanceof StackedYangInstanceIdentifier);
  36             current = current.getParent();
  37         }
  38     }
  39
  40     @Override
  41     public int size() {
  42         int ret = size;
  43         if (!haveSize) {
  44             ret = calculateSize(identifier.getParent());
  45             size = ret;
  46             haveSize = true;
  47         }
  48
  49         return ret;
  50     }
  51
  52
  53     @Override
  54     public boolean contains(final Object o) {
  55         final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
  56         return Iterators.contains(iterator(), srch);
  57     }
  58
  59     @Override
  60     public PathArgument get(final int index) {
  61         return Iterators.get(iterator(), index);
  62     }
  63
  64     @Override
  65     public int indexOf(final Object o) {
  66         final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
  67         return super.indexOf(srch);
  68     }
  69
  70     @Override
  71     public int lastIndexOf(final Object o) {
  72         final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
  73
  74         int ret = -1;
  75         final Iterator<PathArgument> it = iterator();
  76         for (int i = 0; it.hasNext(); ++i) {
  77             if (srch.equals(it.next())) {
  78                 ret = i;
  79             }
  80         }
  81
  82         return ret;
  83     }
  84
  85     @Override
  86     public UnmodifiableIterator<PathArgument> iterator() {
  87         return new IteratorImpl(identifier);
  88     }
  89
  90     private static final class IteratorImpl extends UnmodifiableIterator<PathArgument> {
  91         private StackedYangInstanceIdentifier identifier;
  92         private Iterator<PathArgument> tail;
  93
  94         IteratorImpl(final StackedYangInstanceIdentifier identifier) {
  95             this.identifier = Preconditions.checkNotNull(identifier);
  96         }
  97
  98         @Override
  99         public boolean hasNext() {
 100             return tail == null || tail.hasNext();
 101         }
 102
 103         @Override
 104         public PathArgument next() {
 105             if (tail != null) {
 106                 return tail.next();
 107             }
 108
 109             final PathArgument ret = identifier.getLastPathArgument();
 110             final YangInstanceIdentifier next = identifier.getParent();
 111             final Iterable<PathArgument> args = next.tryReversePathArguments();
 112             if (args != null) {
 113                 tail = args.iterator();
 114                 identifier = null;
 115             } else {
 116                 Verify.verify(next instanceof StackedYangInstanceIdentifier);
 117                 identifier = (StackedYangInstanceIdentifier) next;
 118             }
 119
 120             return ret;
 121         }
 122     }
 123 }