Java ListIterator.hasPrevious方法代码示例

import java.util.ListIterator; //导入方法依赖的package包/类
private static CanvasObject getPrevious(CanvasObject query, List<CanvasObject> objs, CanvasModel model,
		Collection<? extends CanvasObject> ignore) {
	int index = getIndex(query, objs);
	if (index <= 0) {
		return null;
	} else {
		Set<CanvasObject> set = toSet(model.getObjectsOverlapping(query));
		ListIterator<CanvasObject> it = objs.listIterator(index);
		while (it.hasPrevious()) {
			CanvasObject o = it.previous();
			if (set.contains(o) && !ignore.contains(o))
				return o;
		}
		return null;
	}
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public ElasticsearchPrel getConvertedTree() {
  ElasticsearchPrel subTree = (ElasticsearchPrel) this.child;


  if (filterExprs != null) {
    subTree = new ElasticsearchFilter(subTree.getCluster(), subTree.getTraitSet(), subTree, filterExprs, subTree.getPluginId());
  }

  if (projectExprs != null) {
    subTree = new ElasticsearchProject(subTree.getCluster(), subTree.getTraitSet(), subTree, projectExprs, projectDataType, subTree.getPluginId());
  }

  if (parents != null && !parents.isEmpty()) {
    ListIterator<ElasticsearchPrel> iterator = parents.listIterator(parents.size());
    while (iterator.hasPrevious()) {
      final ElasticsearchPrel parent = iterator.previous();
      subTree = (ElasticsearchPrel) parent.copy(parent.getTraitSet(), Collections.singletonList((RelNode) subTree));
    }
  }

  return subTree;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
@Override
public final Iterator<Object> descendingIterator() {
    final ListIterator<Object> it = listIterator(size());
    return new Iterator<Object>() {
        @Override
        public boolean hasNext() {
            return it.hasPrevious();
        }

        @Override
        public Object next() {
            return it.previous();
        }

        @Override
        public void remove() {
            it.remove();
        }
    };
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Test of hasPrevious method, of class TreeListIterator.
 */
@Test
public void testHasPrevious() {
    ListIterator<TreeNode> treeListIterator1 = new TreeListIterator(tree1);
    boolean expResult = true;
    for(int i = 0; i < 14; i++) {
        treeListIterator1.next();
    }
    boolean result = treeListIterator1.hasPrevious();
    assertEquals("hasPrevious method, of class TreeListIterator's expected result is wrong.",
            expResult, result);

    ListIterator<TreeNode> treeListIterator2 = new TreeListIterator(tree2);
    expResult = false;
    result = treeListIterator2.hasPrevious();
    assertEquals("hasPrevious method, of class TreeListIterator's expected result is wrong.",
            expResult, result);
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Returns an iterator for the specified glyphs, sorted either ascending or descending.
 * 
 * @param glyphs The glyphs to return if present
 * @return An iterator of the sorted list of glyphs
 */
private Iterator getIterator(List glyphs) {
	if (orderAscending) return glyphs.iterator();
	final ListIterator iter = glyphs.listIterator(glyphs.size());
	return new Iterator() {
		public boolean hasNext () {
			return iter.hasPrevious();
		}

		public Object next () {
			return iter.previous();
		}

		public void remove () {
			iter.remove();
		}
	};
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public TCType checkType(POExpression exp, TCType expected)
{
	ListIterator<POContext> p = this.listIterator(size());

	while (p.hasPrevious())
	{
		POContext c = p.previous();

		if (c.isScopeBoundary())
		{
			break;		// Change of name scope for expressions.
		}

		TCType t = c.checkType(exp);

		if (t != null)
		{
			return t;
		}
	}

	return expected;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public int searchBackwards(String searchTerm, int startIndex, boolean startsWith) {
    ListIterator<History.Entry> it = history.entries(startIndex);
    while (it.hasPrevious()) {
        History.Entry e = it.previous();
        if (startsWith) {
            if (e.value().toString().startsWith(searchTerm)) {
                return e.index();
            }
        } else {
            if (e.value().toString().contains(searchTerm)) {
                return e.index();
            }
        }
    }
    return -1;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
private static void addSeenViews(List<RouterTransaction> stack, ViewGroup container) {
  ListIterator<RouterTransaction> iterable = stack.listIterator(stack.size());
  int index = container.getChildCount();
  boolean isTop = true;
  while(iterable.hasPrevious()) {
    Controller controller = iterable.previous().controller();
    // Ensure the view is shown
    View view = controller.getView();
    if (view == null) {
      view = controller.inflate(container);
    }
    if (view.getParent() == null) {
      container.addView(view, index);
    }
    // Update index
    index = container.indexOfChild(view);
    // Check controller opacity
    int opacity = getControllerOpacity(controller);
    if (opacity == ControllerOpacity.OPAQUE ||
        (opacity == ControllerOpacity.TRANSLUCENT && !isTop)) {
      // The controllers below can't be seen
      break;
    }
    isTop = false;
  }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * @return last non-empty result from input persisters
 */
@Override
public List<ConfigSnapshotHolder> loadLastConfigs()  {
    // iterate in reverse order
    ListIterator<PersisterWithConfiguration> li = persisterWithConfigurations.listIterator(persisterWithConfigurations.size());
    while(li.hasPrevious()) {
        PersisterWithConfiguration persisterWithConfiguration = li.previous();
        List<ConfigSnapshotHolder> configs = null;
        try {
            configs = persisterWithConfiguration.storage.loadLastConfigs();
        } catch (final IOException e) {
            throw new RuntimeException("Error while calling loadLastConfig on " +  persisterWithConfiguration, e);
        }
        if (!configs.isEmpty()) {
            LOG.debug("Found non empty configs using {}:{}", persisterWithConfiguration, configs);
            return configs;
        }
    }
    // no storage had an answer
    LOG.debug("No non-empty list of configuration snapshots found");
    return Collections.emptyList();
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
@Override
   @SuppressWarnings( {"unchecked"})
public void destroy() {
	if ( !active ) {
		return;
	}

	active = false;
	try {
		synchronized (serviceBindingList) {
			ListIterator<ServiceBinding> serviceBindingsIterator = serviceBindingList.listIterator(
					serviceBindingList.size()
			);
			while ( serviceBindingsIterator.hasPrevious() ) {
				final ServiceBinding serviceBinding = serviceBindingsIterator.previous();
				serviceBinding.getLifecycleOwner().stopService( serviceBinding );
			}
			serviceBindingList.clear();
		}
		serviceBindingMap.clear();
	}
	finally {
		parent.deRegisterChild( this );
	}
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
private void _renderIconRowRtl(
  FacesContext     context,
  RenderingContext rc,
  UIXProcess       process,
  Train            train
  ) throws IOException
{
  ParentTrain parentTrain = train.getParentTrain();

  // Render parent end
  if(parentTrain != null && parentTrain.hasParentEnd())
  {
    _renderParentEndRtl(context, rc, process, train);
  }

  List<Station>         stations = train.getStations();
  ListIterator<Station> iterator = stations.listIterator(stations.size());
  while(iterator.hasPrevious())
  {
    _renderStationIconRtl(context, rc, process, iterator.previous());
  }

  // Render parent start
  if(parentTrain != null && parentTrain.hasParentStart())
  {
    _renderParentStartRtl(context, rc, process, train);
  }

}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public boolean resetOffset(long offset) {
    MappedFile mappedFileLast = getLastMappedFile();

    if (mappedFileLast != null) {
        long lastOffset = mappedFileLast.getFileFromOffset() +
            mappedFileLast.getWrotePosition();
        long diff = lastOffset - offset;

        final int maxDiff = this.mappedFileSize * 2;
        if (diff > maxDiff)
            return false;
    }

    ListIterator<MappedFile> iterator = this.mappedFiles.listIterator();

    while (iterator.hasPrevious()) {
        mappedFileLast = iterator.previous();
        if (offset >= mappedFileLast.getFileFromOffset()) {
            int where = (int) (offset % mappedFileLast.getFileSize());
            mappedFileLast.setFlushedPosition(where);
            mappedFileLast.setWrotePosition(where);
            mappedFileLast.setCommittedPosition(where);
            break;
        } else {
            iterator.remove();
        }
    }
    return true;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Select comment closest to lookup element. Assume comments to be ordered list. Ignores comments starting with
 * doublestar.
 *
 * @param comments
 *            list of commnets on luukup elements
 * @throws InstantiationException
 *             if comment is malformed
 */
protected CommentCandidate pickCommentNoDoubleStar(List<INode> comments) throws InstantiationException {
	ListIterator<INode> iter = comments.listIterator(comments.size());
	String candidateTextString = null;
	while (iter.hasPrevious()) {
		candidateTextString = iter.previous().getText();
		if (!candidateTextString.startsWith("/**")) {
			return new CommentCandidate(candidateTextString);
		}
	}
	return null;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Releases for normal dispatching to the current focus owner all
 * KeyEvents which were enqueued because of a call to
 * {@code enqueueKeyEvents} with the same timestamp and Component.
 * If the given timestamp is less than zero, the outstanding enqueue
 * request for the given Component with the <b>oldest</b> timestamp (if
 * any) should be cancelled.
 *
 * @param after the timestamp specified in the call to
 *        {@code enqueueKeyEvents}, or any value &lt; 0
 * @param untilFocused the Component specified in the call to
 *        {@code enqueueKeyEvents}
 * @see #enqueueKeyEvents
 * @see #discardKeyEvents
 */
protected synchronized void dequeueKeyEvents(long after,
                                             Component untilFocused) {
    if (untilFocused == null) {
        return;
    }

    if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
        focusLog.finer("Dequeue at {0} for {1}",
                   after, untilFocused);
    }

    TypeAheadMarker marker;
    ListIterator<TypeAheadMarker> iter = typeAheadMarkers.listIterator
        ((after >= 0) ? typeAheadMarkers.size() : 0);

    if (after < 0) {
        while (iter.hasNext()) {
            marker = iter.next();
            if (marker.untilFocused == untilFocused)
            {
                iter.remove();
                return;
            }
        }
    } else {
        while (iter.hasPrevious()) {
            marker = iter.previous();
            if (marker.untilFocused == untilFocused &&
                marker.after == after)
            {
                iter.remove();
                return;
            }
        }
    }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
private void freeCachedConnections() {
    /*
     * Remove each connection whose time out has expired.
     */
    synchronized (freeList) {
        int size = freeList.size();

        if (size > 0) {
            long time = System.currentTimeMillis();
            ListIterator<TCPConnection> iter = freeList.listIterator(size);

            while (iter.hasPrevious()) {
                TCPConnection conn = iter.previous();
                if (conn.expired(time)) {
                    TCPTransport.tcpLog.log(Log.VERBOSE,
                        "connection timeout expired");

                    try {
                        conn.close();
                    } catch (java.io.IOException e) {
                        // eat exception
                    }
                    iter.remove();
                }
            }
        }

        if (freeList.isEmpty()) {
            reaper.cancel(false);
            reaper = null;
        }
    }
}