Removes an element from the List. All following elements
are moved down by one index.
@param  idx  index of the element to remove
434107
public void remove(int idx) {
        size--;
        System.arraycopy(data, idx + 1, data, idx, size - idx);
    }
400128
private void remove(int listIndex)
    {
        if (listIndex == 0)
        {
            // Trivially remove from head.
            ivElements[ivHeadIndex++] = null;
        }
        else if (listIndex == ivTailIndex - 1)
        {
            // Trivially remove from tail.
            ivElements[--ivTailIndex] = null;
        }
        else
        {
            // Determine whether shifting the head or the tail requires the lower
            // number of element copies.

            int size = size();
            int halfSize = size >> 1;
            if (listIndex < halfSize)
            {
                // The index is less than half.  Shift the elements at the head of
                // the array up one index to cover the removed element.
                System.arraycopy(ivElements, ivHeadIndex, ivElements, ivHeadIndex + 1, listIndex);
                ivElements[ivHeadIndex++] = null;
            }
            else
            {
                // The index is more than half.  Shift the elements at the tail of
                // the array down one index to cover the removed element.
                int arrayIndex = ivHeadIndex + listIndex;
                System.arraycopy(ivElements, arrayIndex + 1, ivElements, arrayIndex, size - listIndex - 1);
                ivElements[--ivTailIndex] = null;
            }
        }

        if (isEmpty())
        {
            // Reset ivHeadIndex to 0 to avoid element copies in add().
            ivHeadIndex = 0;
            ivTailIndex = 0;
        }
    }
1042186
public void removeAt(int index) {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.remove(index);
            } else {
                mObjects.remove(index);
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
728907
public void removeRegularRow(final int idx) {
        DynaFormRow rowToBeRemoved = null;
        if (0 <= idx && idx < regularRows.size()) {
            rowToBeRemoved = regularRows.get(idx);
        }

        if (rowToBeRemoved != null) {
            removeRow(regularRows, rowToBeRemoved, idx);
        }
    }
745201
private T doRemove(int index) {
        keys[index]   = 0;
        states[index] = REMOVED;
        final Object previous = values[index];
        values[index] = missingEntries;
        --size;
        ++count;
        return (T)previous;
    }
19693
def remove(self, iid):
        '''
            
        '''
        for index in iid:
            target = Target.getTarget(index)

            target.delete()
1322653
public Object remove(int index) {

        if (index >= elementCount) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " >= "
                                                + elementCount);
        }

        if (index < 0) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " < 0");
        }

        Object removedObj = elementData[index];

        for (int i = index; i < elementCount - 1; i++) {
            elementData[i] = elementData[i + 1];
        }

        elementCount--;

        if (elementCount == 0) {
            clear();
        } else {
            elementData[elementCount] = null;
        }

        return removedObj;
    }
880101
public void removeChildAt(int index) throws IndexOutOfBoundsException {
        Node<T> child = children.get(index);
        child.parent = null;
        children.remove(index);
    }
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();
    }
908833
public void removeElementAt(int i)
  {

    if (null == m_map)
      return;

    if (i > m_firstFree)
      System.arraycopy(m_map, i + 1, m_map, i - 1, m_firstFree - i);
    else
      m_map[i] = DTM.NULL;
  }
449167
public void remove(int i) {
        Iterator<Entry> it = array.iterator();
        while (it.hasNext()) {
            Entry e = it.next();
            if (e.i == i) {
                it.remove();
                break;
            }
        }
    }
111227
@Override
    public void delete(int index)
    {
        checkNotSealed(null, index);
        slotMap.remove(null, index);
    }
250233
public void clear(int index) {
        if(index < 0 || index >= size)
            throw new IndexOutOfBoundsException("index: " + index);

        int wordIndex=wordIndex(index);
        words[wordIndex]&=~(1L << index);
    }
1237857
function remove(client) {
  if(!clients) {
    return;
  }

  var idx = clients.indexOf(client);
  if(idx > -1) {
    clients.splice(idx, 1);
  }
}
120879
public JsonElement remove(int index) {
        checkIfFrozen();
        if (index < 0 || index >= values.size()) {
            return null;
        }
        return values.remove(index);
    }
1001663
public boolean removeB(int index)
    {
        boundsCheck(index);
        boolean ret = array[index];
        for(int i = index; i < end-1; i++)
            array[i] = array[i+1];
        decreaseSize(1);
        return ret;
    }
680989
def delete(self, index=None):
        
        if index is None:
            javabridge.call(self.jobject, "delete", "()V")
        else:
            javabridge.call(self.jobject, "delete", "(I)V", index)