deselects all items at the positions in the iteratable

@param positions the global positions to deselect
353085
public void deselect(Iterable<Integer> positions) {
        Iterator<Integer> entries = positions.iterator();
        while (entries.hasNext()) {
            deselect(entries.next(), entries);
        }
    }
280536
public DrawerView removeItem(int position) {
        mAdapter.getItem(position).detach();
        mAdapter.remove(mAdapter.getItem(position));
        updateList();
        return this;
    }
766748
public List<Item> deleteAllSelectedItems() {
        List<Item> deletedItems = new ArrayList<>();

        final List<Integer> positions = new ArrayList<>();
        mFastAdapter.recursive(new AdapterPredicate<Item>() {
            @Override
            public boolean apply(@NonNull IAdapter<Item> lastParentAdapter, int lastParentPosition, Item item, int position) {
                if (item.isSelected()) {
                    //if it's a subitem remove it from the parent
                    if (item instanceof ISubItem) {
                        //a sub item which is not in the list can be instantly deleted
                        IExpandable parent = (IExpandable) ((ISubItem) item).getParent();
                        //parent should not be null, but check in any case..
                        if (parent != null) {
                            parent.getSubItems().remove(item);
                        }
                    }
                    if (position != -1) {
                        //a normal displayed item can only be deleted afterwards
                        positions.add(position);
                    }
                }
                return false;
            }
        }, false);

        //we have to re-fetch the selections array again and again as the position will change after one item is deleted
        for (int i = positions.size() - 1; i >= 0; i--) {
            FastAdapter.RelativeInfo<Item> ri = mFastAdapter.getRelativeInfo(positions.get(i));
            if (ri.item != null && ri.item.isSelected()) { //double verify
                if (ri.adapter != null && ri.adapter instanceof IItemAdapter) {
                    ((IItemAdapter) ri.adapter).remove(positions.get(i));
                }
            }
        }
        return deletedItems;
    }
1297191
public void recycle(RecyclePosition position) {

        stubCount = determineStubCount();

        switch (position) {
            case BOTTOM:
                if (hasRecycledWidgets()) {
                    // Will remove the  current recycled widgets
                    remove(getRecycledWidgets().stream()
                            .skip(0)
                            .limit((parent.getLimit() * (currentIndex + 1)) - stubCount)
                            .collect(Collectors.toList()));

                    currentIndex++;

                    // Will determine if the current index is greater than the load index then we need to recycle the next
                    // set of recycled widgets
                    if (currentIndex < loadIndex) {
                        add(getRecycledWidgets(currentIndex));
                    }
                }
                break;
            case TOP:
                if (currentIndex > 0) {
                    // Will remove the current recycled widgets
                    remove(getRecycledWidgets(currentIndex));

                    // Will add the previous recycled widgets
                    int skip = ((parent.getLimit() * currentIndex) - parent.getLimit()) - stubCount;
                    insert(getRecycledWidgets().stream()
                            .skip(skip < 0 ? 0 : skip)
                            .limit(parent.getLimit())
                            .collect(Collectors.toList()));

                    currentIndex--;
                }
                break;
        }
    }
96392
public ModelAdapter<Model, Item> remove(int position) {
        mItems.remove(position, getFastAdapter().getPreItemCount(position));
        return this;
    }
383084
public DrawerView removeFixedItem(int position) {
        mAdapterFixed.getItem(position).detach();
        mAdapterFixed.remove(mAdapterFixed.getItem(position));
        updateFixedList();
        return this;
    }
415453
public void clear(boolean undoAll) {
    LOGGER.trace("Clear called, with undoAll: " + undoAll);
    if (undoAll) {
      undoAll();
    }
    LOGGER.trace("Clearing changes");
    changes.clear();
    position.set(-1);
    validPosition.set(-1);
  }
339217
public static void selectSort(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            int lowIndex = i;
            for (int j = i + 1; j < arrays.length; j++) {
                if (arrays[j] < arrays[lowIndex]) {
                    lowIndex = j;
                }
            }
            if (lowIndex != i) {
                switchNumber(arrays, i, lowIndex);
            }
        }
    }
737686
@Override
	public void prune() {
		Iterator<PointIndex<Point>> iter = allPoints.iterator();
		int index = 0;
		while( iter.hasNext() ) {
			iter.next();
			if (origErrors[index++] >= pruneVal) {
				iter.remove();
			}
		}
	}
1283643
public ModelAdapter<?, Item> removeRange(int position, int itemCount) {
        if (mOriginalItems != null) {
            //global position to relative
            int length = mOriginalItems.size();
            int preItemCount = mItemAdapter.getFastAdapter().getPreItemCount(position);
            //make sure we do not delete to many items
            int saveItemCount = Math.min(itemCount, length - position + preItemCount);
            for (int i = 0; i < saveItemCount; i++) {
                mOriginalItems.remove(position - preItemCount);
            }
            publishResults(mConstraint, performFiltering(mConstraint));
            return mItemAdapter;
        } else {
            return mItemAdapter.removeRange(position, itemCount);
        }
    }
979586
public static void removeAll() {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
        if (threadLocalMap == null) {
            return;
        }

        try {
            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
            if (v != null && v != InternalThreadLocalMap.UNSET) {
                @SuppressWarnings("unchecked")
                Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
                FastThreadLocal<?>[] variablesToRemoveArray =
                        variablesToRemove.toArray(new FastThreadLocal[0]);
                for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                    tlv.remove(threadLocalMap);
                }
            }
        } finally {
            InternalThreadLocalMap.remove();
        }
    }
701476
@Deprecated
	public void setSelectedItems(final List<WComponent> selectedItems) {
		if (selectedItems == null || selectedItems.isEmpty()) {
			setSelectedMenuItems(null);
		} else {
			List<MenuItemSelectable> items = new ArrayList(selectedItems);
			setSelectedMenuItems(items);
		}
	}
798830
public void clearSelection() {
    List<CalendarDay> dates = getSelectedDates();
    adapter.clearSelections();
    for (CalendarDay day : dates) {
      dispatchOnDateSelected(day, false);
    }
  }
163624
public void setJobs(java.util.Collection<Job> jobs) {
        if (jobs == null) {
            this.jobs = null;
            return;
        }

        this.jobs = new java.util.ArrayList<Job>(jobs);
    }
543521
function clearSelectionEvents(array) {
    while (array.length) {
      var last = lst(array);
      if (last.ranges) array.pop();
      else break;
    }
  }
825114
@SuppressWarnings("unused")
    public void selectItem(int position, boolean invokeListeners) {
        IOperationItem item = mOuterAdapter.getItem(position);
        IOperationItem oldHidedItem = mOuterAdapter.getItem(mRealHidedPosition);

        int realPosition = mOuterAdapter.normalizePosition(position);
        //do nothing if position not changed
        if (realPosition == mCurrentItemPosition) {
            return;
        }
        int itemToShowAdapterPosition = position - realPosition + mRealHidedPosition;

        item.setVisible(false);

        startSelectedViewOutAnimation(position);

        mOuterAdapter.notifyRealItemChanged(position);
        mRealHidedPosition = realPosition;

        oldHidedItem.setVisible(true);
        mFlContainerSelected.requestLayout();
        mOuterAdapter.notifyRealItemChanged(itemToShowAdapterPosition);
        mCurrentItemPosition = realPosition;

        if (invokeListeners) {
            notifyItemClickListeners(realPosition);
        }

        if (BuildConfig.DEBUG) {
            Log.i(TAG, "clicked on position =" + position);
        }

    }
167029
public void setSelection(int position) {
        DropDownListView list = mDropDownList;
        if (isShowing() && list != null) {
            list.mListSelectionHidden = false;
            list.setSelection(position);

            if (Build.VERSION.SDK_INT >= 11) {
                if (list.getChoiceMode() != ListView.CHOICE_MODE_NONE) {
                    list.setItemChecked(position, true);
                }
            }
        }
    }