Scrolls down a RecyclerView matching the specified index.

@param index the index of the RecyclerView to scroll. {@code 0} if only one RecyclerView is available
@return {@code true} if more scrolling can be performed
553247
public boolean scrollDownRecyclerView(int index) {
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "scrollDownRecyclerView("+index+")");
		}
		
		if(!config.shouldScroll) {
			return true;
		}
		
		View recyclerView = viewFetcher.getRecyclerView(index, Timeout.getSmallTimeout());
	
		return scroller.scrollView(recyclerView, Scroller.DOWN);
		
	}
435078
@SuppressWarnings("unchecked")
    public V get(int index) {
	int pos = Arrays.binarySearch(keyIndices, index);
	return (pos >= 0) ? (V)(values[pos]) : null;	
    }
254231
public void setIndex(int index) {
        ElementBase parent = getParent();
        
        if (parent == null) {
            CWFException.raise("Element has no parent.");
        }
        
        int currentIndex = parent.children.indexOf(this);
        
        if (currentIndex < 0 || currentIndex == index) {
            return;
        }
        
        parent.moveChild(currentIndex, index);
    }
1011110
public boolean deleteEntry(int index) {
    System.arraycopy(entries, index + 1, entries, index, numEntries - index - 1);
    entries[--numEntries] = null;
    return true;
  }
915622
public final void remove(final int index) {
        AbstractItem removedItem = items.remove(index);

        if (removedItem instanceof Item && ((Item) removedItem).getIcon() != null) {
            iconCount--;
        } else if (removedItem instanceof Divider) {
            dividerCount--;
        }

        rawItems = null;
        notifyOnDataSetChanged();
    }
13476
public DrawableParent getDrawableParentForIndex(int index) {
    Preconditions.checkArgument(index >= 0);
    Preconditions.checkArgument(index < mDrawableParents.length);
    if (mDrawableParents[index] == null) {
      mDrawableParents[index] = createDrawableParentForIndex(index);
    }
    return mDrawableParents[index];
  }
1273371
protected void recycleChildren(RecyclerView.Recycler recycler, int startIndex, int endIndex) {
        if (startIndex == endIndex) {
            return;
        }
        if (DEBUG) {
            Log.d(TAG, "Recycling " + Math.abs(startIndex - endIndex) + " items");
        }
        if (endIndex > startIndex) {
            for (int i = endIndex - 1; i >= startIndex; i--) {
                removeAndRecycleViewAt(i, recycler);
            }
        } else {
            for (int i = startIndex; i > endIndex; i--) {
                removeAndRecycleViewAt(i, recycler);
            }
        }
    }
57428
public boolean scrollListToTop(int index) {
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "scrollListToTop("+index+")");
		}
		
		return scroller.scrollList(waiter.waitForAndGetView(index, ListView.class), Scroller.UP, true);
	}
279908
public boolean scrollListToBottom(int index) {
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "scrollListToBottom("+index+")");
		}
		
		return scroller.scrollList(waiter.waitForAndGetView(index, ListView.class), Scroller.DOWN, true);
	}
135805
public void compact(long index) {
    Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
    if (segmentEntry != null) {
      SortedMap<Long, JournalSegment<E>> compactSegments = segments.headMap(segmentEntry.getValue().index());
      if (!compactSegments.isEmpty()) {
        log.debug("{} - Compacting {} segment(s)", name, compactSegments.size());
        for (JournalSegment segment : compactSegments.values()) {
          log.trace("Deleting segment: {}", segment);
          segment.close();
          segment.delete();
        }
        compactSegments.clear();
        resetHead(segmentEntry.getValue().index());
      }
    }
  }
72137
public boolean bufferKestrelGet(int index)
    {
        KestrelClientInfo info = this.clientInfoList.get(index);

        long now = System.currentTimeMillis();
        if (now > info.blacklistTillTimeMs)
        {
            List<Item> items = null;
            try
            {
                items = info.getValidClient().get(this.queueName, DEFAULT_BATCH_SIZE, 0,
                        this.messageTimeoutMs);
            }
            catch (TException e)
            {
                blacklist(info, e);
                return false;
            }

            Set<Long> toAck = Sets.newHashSet();

            for (Item item : items)
            {
                Iterable<List<Object>> retItems = this.messageScheme.deserialize(item.get_data());

                if (retItems != null)
                {
                    for (List<Object> retItem : retItems)
                    {
                        EmitItem emitItem = generateEmitItem(retItem, new KestrelSourceId(index,
                                item.get_id()));

                        if (!this.emitBuffer.offer(emitItem))
                        {
                            throw new RuntimeException(
                                    "KestrelThriftSpout's Internal Buffer Enqeueue Failed.");
                        }
                    }

                }
                else
                {
                    toAck.add(item.get_id());
                }
            }

            if (toAck.size() > 0)
            {
                try
                {
                    info.getClient().confirm(this.queueName, toAck);
                }
                catch (TException e)
                {
                    blacklist(info, e);
                }
            }

            if (items.size() > 0)
            {
                return true;
            }
        }
        return false;
    }
570571
@SuppressWarnings("unchecked")
  private void applyIndex(long index) {
    // Apply entries prior to this entry.
    if (reader.hasNext() && reader.getNextIndex() == index) {
      // Read the entry from the log. If the entry is non-null then apply it, otherwise
      // simply update the last applied index and return a null result.
      Indexed<RaftLogEntry> entry = reader.next();
      try {
        if (entry.index() != index) {
          throw new IllegalStateException("inconsistent index applying entry " + index + ": " + entry);
        }
        CompletableFuture future = futures.remove(index);
        apply(entry).whenComplete((r, e) -> {
          raft.setLastApplied(index);
          if (future != null) {
            if (e == null) {
              future.complete(r);
            } else {
              future.completeExceptionally(e);
            }
          }
        });
      } catch (Exception e) {
        logger.error("Failed to apply {}: {}", entry, e);
      }
    } else {
      CompletableFuture future = futures.remove(index);
      if (future != null) {
        logger.error("Cannot apply index " + index);
        future.completeExceptionally(new IndexOutOfBoundsException("Cannot apply index " + index));
      }
    }
  }
1202529
private boolean notifyOnNext(final int index) {
        boolean result = true;

        for (WizardListener listener : wizardListeners) {
            result &= listener.onNext(index, viewPagerAdapter.getItem(index));
        }

        return result;
    }
541473
def on_recycle_view(self, index, position):
        
        item = self.list_items[index]
        self.item_mapping[position] = item
        item.recycle_view(position)
17561
public Object opt(int index) {
		return (index < 0 || index >= this.length()) ? null : this.list
				.get(index);
	}
71974
public final boolean isItemEnabled(final int index) {
        AbstractItem item = items.get(index);
        return item instanceof Item && ((Item) item).isEnabled();
    }
547630
public boolean writeHistoryEnabledForIndex(String index) {

        if(index == null) {
            return false;
        }
        
        if(searchguardIndex.equals(index)) {
            return logInternalConfig;
        }

        if(auditLogIndex != null && auditLogIndex.equalsIgnoreCase(index)) {
            return false;
        }

        if(auditLogPattern != null) {
            if(index.equalsIgnoreCase(getExpandedIndexName(auditLogPattern, null))) {
                return false;
            }
        }

        return WildcardMatcher.matchAny(watchedWriteIndices, index);
    }