Removes and returns the an item from this GeventDeque.

        This is an internal method, called by the public methods
        pop() and popleft().
177774
def _pop(self, block=True, timeout=None, left=False):
        
        item  = None
        timer = None
        deque = self._deque
        empty = IndexError('pop from an empty deque')

        if block is False:
            if len(self._deque) > 0:
                item = deque.popleft() if left else deque.pop()
            else:
                raise empty
        else:
            try:
                if timeout is not None:
                    timer = gevent.Timeout(timeout, empty)
                    timer.start()

                while True:
                    self.notEmpty.wait()
                    if len(deque) > 0:
                        item = deque.popleft() if left else deque.pop()
                        break
            finally:
                if timer is not None:
                    timer.cancel()

        if len(deque) == 0:
            self.notEmpty.clear()

        return item
32632
def remove(self, item):
        
        if item not in self:
            raise ValueError('objectlist.remove(item) failed, item not in list')
        item_path = self._view_path_for(item)
        giter = self._iter_for(item)
        del self[giter]
        self.emit('item-removed', item, item_path)
974574
def child_removed(self, child):
        
        super(AbstractItemView, self).child_removed(child)
        self.get_member('_items').reset(self)
641427
def removeItem( self, item ):
        
        # for nodes and connections, call the prepareToRemove method before 
        # removing
        if ( isinstance( item, XNode ) or 
             isinstance( item, XNodeConnection ) ):
            # make sure this item is ok to remove
            if ( not item.prepareToRemove() ):
                return False
        
        # remove the item using the base class method
        try:
            self._cache.remove(item)
        except KeyError:
            pass
        
        # mark the scene as modified
        self.setModified(True)
        super(XNodeScene, self).removeItem(item)
        
        if not self.signalsBlocked():
            self.itemsRemoved.emit()
        
        return True
1225845
public function pop_back()
    {
        if ($this->count() <= 0) {
            throw new \OutOfBoundsException();
        }

        $item = $this->list[$this->count() - 1];

        $this->removeLast();

        return $item;
    }
783385
def popitem(self):
        
        try:
            value = next(iter(self))
            key = value[self._keycol]
        except StopIteration:
            raise KeyError
        del self[key]
        return key, value
1268851
def pop(self, identifier, default=None):
        
        if identifier in self.children:
            item = self[identifier]
            self.__delitem__(identifier)
            return item
        else:
            return default
305135
def popitem(self):
        """"""
        pq = self.pq
        while pq:
            priority, key, val = heapq.heappop(pq)
            if val is None:
                self.removed_count -= 1

            else:
                del self.item_finder[key]
                return key, val, priority

        raise KeyError("pop from an empty priority queue")
738953
def remove(self, item):
        ''''''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score
165780
def pop(self, key, *args, **kwargs):
        
        try:
            val = self[key]
        except KeyError:
            if len(args):
                return args[0]
            if "default" in kwargs:
                return kwargs["default"]
            raise

        try:
            del(self[key])
        except KeyError:
            pass

        return val
599163
def pop(self, key=-1):
    """"""
    value = self._values[key]
    self.__delitem__(key)
    return value
1025775
@Override
	public synchronized IPOContext pop()
	{

		IPOContext obj = peek();
		int len = size();
		for (int i = len - 1; i >= 0; i--)
		{
			if (!this.get(i).isStateful())
			{
				removeElementAt(i);
				return obj;
			}
		}

		return obj;
	}
204993
def remove(self, item):
        '''

        '''
        match = self.match(item)
        if match is None:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )

        index = int(match.group('index'))
        try:
            self.indexes.remove(index)
        except KeyError:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )
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
1176965
def remove_item(self, item):
        
        for idx, _item in enumerate(self.items):
            if item == _item:
                del self.items[idx]
                return True
        return False
1347128
def pop(self):
        
        try:
            return self._collection.pop()
        except KeyError:
            raise KeyError("Nothing left in the {}: '{}'.".format(type(self).__name__, self)) from None
721426
def removeSelection( self ):
        
        results = self.removeItems( self.selectedItems() )
        self.emitSelectionFinished()
        return results