Remove the given C{item} from the sequence.

        @raises L{WSDLParseError}: If the operation would result in having
             less child elements than the required min_occurs, or if no such
             index is found.
493262
def remove(self, item):
        
        for index, child in enumerate(self._root.getchildren()):
            if child is item._root:
                del self[index]
                return item
        raise WSDLParseError("Non existing item in tag '%s'" %
                               self._schema.tag)
839598
private void removeIndexTermRecursive(final Element parent) {
        if (parent == null) {
            return;
        }
        final NodeList children = parent.getChildNodes();
        Element child;
        for (int i = children.getLength() - 1; i >= 0; i--) {
            if (children.item(i).getNodeType() == Node.ELEMENT_NODE) {
                child = (Element) children.item(i);
                final boolean isIndexTerm = TOPIC_INDEXTERM.matches(child);
                final boolean hasStart = !child.getAttribute(ATTRIBUTE_NAME_START).isEmpty();
                final boolean hasEnd = !child.getAttribute(ATTRIBUTE_NAME_END).isEmpty();
                if (isIndexTerm && (hasStart || hasEnd)) {
                    parent.removeChild(child);
                } else {
                    removeIndexTermRecursive(child);
                }
            }
        }
    }
884432
def remove_child(self, index):
        
        if index < 0:
            index = index + len(self)
        self.__children = self.__children[0:index] + self.__children[(index + 1):]
1093113
public void remove(String suggestion) {
        Node n = getNode(suggestion);
        if(n == null)
            return;
        n.weight = -1;
        size--;
        Node m = n;
        if(n.mid == null) {
            Node replacement = removeNode(n);
            if(replacement != null)
                replacement.parent = n.parent;
            if(n == root)
                root = replacement;
            else if(n == n.parent.mid)
                n.parent.mid = replacement;
            else{
                if(n == n.parent.left)
                    n.parent.left = replacement;
                else
                    n.parent.right = replacement;
                while(n != root && n != n.parent.mid)
                    n = n.parent;
            }
            n = n.parent;
            if(n == null)
                return;
        }
        if(n.weight == -1 && n.mid.left == null && n.mid.right == null) {
            n = mergeWithChild(n);
            while(n != root && n != n.parent.mid)
                n = n.parent;
            n = n.parent;
            if(n == null)
                return;
        }
        removeFromLists(m, n);
    }
1066556
public void dispose(int sequence) {
        int index = toIndex(sequence);
        checkSequence(index, sequence);
        if (isTask[index]) {
            callableCounter--;
        }
        ringItems[index] = null;
        isTask[index] = false;
    }
463647
public boolean removeTail()
  {
    CacheItem<K,V> tail = null;

    if (_capacity1 <= _size1)
      tail = _tail1;

    if (tail == null) {
      tail = _tail2;

      if (tail == null) {
        tail = _tail1;

        if (tail == null)
          return false;
      }
    }

    V oldValue = tail._value;
    if (oldValue instanceof LruListener) {
      ((LruListener) oldValue).lruEvent();
    }

    V value = remove(tail._key);

    return true;
  }
359157
public ModelAdapter<Model, Item> removeRange(int position, int itemCount) {
        mItems.removeRange(position, itemCount, getFastAdapter().getPreItemCount(position));
        return this;
    }
127677
private void removeChildrenItems(JDBCStorageConnection conn, ResultSet resultSet) throws SQLException, IllegalNameException,
      IllegalStateException, UnsupportedOperationException, InvalidItemStateException, RepositoryException
   {
      String parentId = resultSet.getString(DBConstants.COLUMN_ID);
      String selectStatement = "select * from " + iTable + " where I_CLASS = 1 and PARENT_ID = '" + parentId + "'";
      String deleteStatement = "delete from " + iTable + " where I_CLASS = 1 and PARENT_ID = '" + parentId + "'";

      // traversing down to the bottom of the tree
      PreparedStatement statement = conn.getJdbcConnection().prepareStatement(selectStatement);
      ResultSet selResult = statement.executeQuery();
      try
      {
         while (selResult.next())
         {
            removeChildrenItems(conn, selResult);
         }
      }
      finally
      {
         JDBCUtils.freeResources(selResult, statement, null);
      }
      
      // remove properties
      NodeData node = createNodeData(resultSet);
      for (PropertyData prop : conn.getChildPropertiesData(node))
      {
         conn.delete(prop, new SimpleChangedSizeHandler());
      }

      // remove nodes
      statement = conn.getJdbcConnection().prepareStatement(deleteStatement);
      try
      {
         statement.execute();
      }
      finally
      {
         JDBCUtils.freeResources(null, statement, null);
      }
   }
707528
def remove(self, item):
        
        check_not_none(item, "Value can't be None")
        item_data = self._to_data(item)
        return self._encode_invoke(list_remove_codec, value=item_data)
298224
def remove(self):
        
        DoubleLinkedListItem.remove(self)     # remove from double linked list
        if self.succ is self:                 # list was a singleton
            self.theclass.items = None        # class is empty
        elif self.theclass.items is self:     # oups we removed the head
            self.theclass.items = self.succ
168481
def remove(self):
        
        if not self._is_item:
            raise TypeError("Should be called on an item, not ListNode's itself.")
        self.container.node_stack.remove(self)
1224103
public synchronized void remove()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "remove");

    if(removable != null)
    {
      index.remove(removable);
    }
    else
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "remove", "IllegalStateException");
      throw new IllegalStateException(
        nls.getFormattedMessage(
          "NO_ELEMENTS_ERROR_CWSIP0602",
          null,
          null));
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "remove");
  }
1036606
def kremove(self, key, value=None):
        
        for item in self:
            if value is None:
                # Just pop the key if present,
                # otherwise return None
                # (shortcut to ignore the exception)
                item.pop(key, None)
            else:
                try:
                    # Use the key as a set
                    item[key].remove(value)
                    # If the set contains a single element
                    # just store the latter
                    if len(item[key]) == 1:
                        item[key] = item[key].pop()
                except KeyError:
                    # This happens when the item
                    # does not contain the key
                    pass
                except AttributeError:
                    # This happens when the key is not a set
                    # and shall be removed only if values match
                    if item[key] == value:
                        item.pop(key)
899193
def delete_item(item)
      Predictor.redis.watch(redis_key(:sets, item)) do
        sets = Predictor.redis.smembers(redis_key(:sets, item))
        Predictor.redis.multi do |multi|
          sets.each do |set|
            multi.srem(redis_key(:items, set), item)
          end

          multi.del redis_key(:sets, item)
        end
      end
    end
679768
def stopword_remove(self, items, threshold=False):

        

        def remove(tokens):
            return [t for t in tokens if t not in self.stopwords]

        if items == 'tokens':
            self.tokens = list(map(remove, self.tokens))
        elif items == 'stems':
            self.stems = list(map(remove, self.stems))
        else:
            raise ValueError("Items must be either \'tokens\' or \'stems\'.")
940117
private void deselectChildren(CmsTreeItem item) {

        for (String childId : m_childrens.get(item.getId())) {
            CmsTreeItem child = m_categories.get(childId);
            deselectChildren(child);
            child.getCheckBox().setChecked(false);
            if (m_selectedCategories.contains(childId)) {
                m_selectedCategories.remove(childId);
            }
        }
    }
151827
public int remove(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    synchronized (this) {
      Item prev = null;
      for (Item item = _entries[hash]; item != null; item = item._next) {
        Object itemKey = item._key;
      
        if (itemKey == key || itemKey.equals(key)) {
          int oldValue = item._value;

          if (prev != null)
            prev._next = item._next;
          else
            _entries[hash] = item._next;

          _size--;

          return oldValue;
        }

        prev = item;
      }
    }

    return NULL;
  }