Removes first

        :return: True iff head has been removed
779845
def remove_first(self):
        

        if self.head is None:
            return False

        self.head = self.head.next_node
        return True
1020627
def headinside(self):
        
        
        h = self.model.head(self.xw + self.rw, self.yw, layers=self.layers)
        return h - self.resfac * self.parameters[:, 0]
1265987
def head(self, urls=None, **overrides):
        """"""
        if urls is not None:
            overrides['urls'] = urls
        return self.where(accept='HEAD', **overrides)
221192
private void clearAllHeaders() {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isEntryEnabled()) {
            Tr.entry(tc, "clearAllHeaders()");
        }

        HeaderElement elem = this.hdrSequence;
        while (null != elem) {
            final HeaderElement next = elem.nextSequence;
            final HeaderKeys key = elem.getKey();
            final int ord = key.getOrdinal();
            if (storage.containsKey(ord)) {
                // first instance being removed
                if (key.useFilters()) {
                    filterRemove(key, null);
                }
                storage.remove(ord);
            }
            elem.destroy();
            elem = next;
        }
        this.hdrSequence = null;
        this.lastHdrInSequence = null;
        this.numberOfHeaders = 0;
        if (bTrace && tc.isEntryEnabled()) {
            Tr.exit(tc, "clearAllHeaders()");
        }
    }
162631
def remove(self, position):
        
        if position <= 0:  # at beginning
            return self.remove_first()

        if position >= self.length() - 1:  # at end
            return self.remove_last()

        counter = 0
        last_node = self.head
        current_node = self.head

        while current_node is not None and counter <= position:
            if counter == position:
                last_node.next_node = current_node.next_node  # remove current
                return True

            last_node = current_node
            current_node = current_node.next_node
            counter += 1

        return False
771122
public void removeHead( int total ) {
		for( int j = total; j < size; j++ ) {
			data[j-total] = data[j];
		}
		size -= total;
	}
601477
def remove_header(self, name):
        """"""
        if name in self.info_dict:
            self.info_dict.pop(name)
            logger.info("Removed '{0}' from INFO".format(name))
        if name in self.filter_dict:
            self.filter_dict.pop(name)
            logger.info("Removed '{0}' from FILTER".format(name))
        if name in self.format_dict:
            self.format_dict.pop(name)
            logger.info("Removed '{0}' from FORMAT".format(name))
        if name in self.contig_dict:
            self.contig_dict.pop(name)
            logger.info("Removed '{0}' from CONTIG".format(name))
        if name in self.alt_dict:
            self.alt_dict.pop(name)
            logger.info("Removed '{0}' from ALT".format(name))
        if name in self.other_dict:
            self.other_dict.pop(name)
            logger.info("Removed '{0}' from OTHER".format(name))
        return
830709
public function removeFromHeadByPosition($position)
    {
        if (isset($position, $this->_head[$position])) {
            unset($this->_head[$position]);
        }
    }
912214
def removed(self):
        
        removed = 0
        for line in self.diff.replace('\r', '').split("\n"):
            if line.startswith('-') and not line.startswith('---'):
                removed += 1
        return removed
157244
public function detachFirst()
    {
        $this->rewind();
        $o = $this->current();
        if (!$o) {
            return false;
        }
        $this->detach($o);
        return $o;
    }
1206596
public T remove()
    {
        if ( size == 0 ) {
            return null;
        }
        
        //remove the first element
        Entry<T> o = head.next;
        head.next   = o.next;
        o.next.prev = head;
        
        //bakup the data
        T v         = o.data;
        size--;
        index.remove(v.getValue());
        
        o = null;            //Let gc do its work
        
        return v;
    }
797080
def main(self, din):
        
        self.shr = self.shr[1:] + [din]

        if self.cooldown > 0:
            self.cooldown = self.cooldown - 1
            return False

        if self.shr != self.HEADER:
            return False

        self.cooldown = self.COOLDOWN_RESET
        return True
401978
@Override
    public boolean removeFirstOccurrence(DelayedEntry incoming) {
        Data incomingKey = (Data) incoming.getKey();
        Object incomingValue = incoming.getValue();

        DelayedEntry current = map.get(incomingKey);
        if (current == null) {
            return false;
        }

        Object currentValue = current.getValue();
        if (incomingValue == null && currentValue == null
                || incomingValue != null && currentValue != null && incomingValue.equals(currentValue)) {
            map.remove(incomingKey);
            return true;
        }

        return false;
    }
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
124247
def head(self, url, *args, **kwargs):
        
        res = self._conn.head(url, headers=self._prepare_headers(**kwargs))
        if res.status_code == 200:
            return res
        return None
481658
def remove(self, first, count):
        

        # Avoid trivialities
        if first < 0 or count < 1:
            return

        new_range = []
        last = first + count - 1
        for r in self.__range:
            if first <= r.last and r.first <= last:
                # There is an overlap
                if r.first < first:
                    new_range.append(IdRange(r.first, first-r.first))
                if last < r.last:
                    new_range.append(IdRange(last+1, r.last-last))
            else:
                # No overlap, range is kept
                new_range.append(r)

        self.__range = new_range
372796
def head(self, path, query=None, data=None, redirects=True):
        
        return self.request('HEAD', path, query, None, redirects)