Remove a node from the stage and put in the working tree

@param string $what what should be removed from the stage

@throws \RuntimeException
@return string
163475
public function unstage($what)
    {
        $this->clearAll();
        $this->addCommandName(self::GIT_RESET);
        $this->addCommandArgument('HEAD');
        $this->addPath($what);

        return $this->getCommand();
    }
261384
public function end()
    {
        if (null === $this->ifPart) {
            throw new \RuntimeException('You must specify an if part.');
        }
        if (null === $this->thenPart) {
            throw new \RuntimeException('You must specify a then part.');
        }

        return $this->node;
    }
804711
public function add($what = '.')
    {
        $this->clearAll();
        $this->addCommandName(self::GIT_ADD);
        $this->addCommandArgument('--all');
        $this->addCommandSubject($what);

        return $this->getCommand();
    }
126987
public function removeChildNode(NodeInterface $childNode){
        $this->childNodes = array_filter($this->childNodes, function($node) use ($childNode){
            return $node !== $childNode;
        });
        return $this;
    }
846199
public function remove()
    {
        unset($this->_nodes[$this->_pointer]);
        $this->_nodes = array_values($this->_nodes);
        return $this;
    }
482462
function remove_at( $i ){
		$Child = $this->children[$i];
		$Child->pidx = null;
		$Child->depth = 0;
		array_splice( $this->children, $i, 1 );
		if( ! --$this->length ){
			$this->p = null;
		}
		else {
			$this->p = 0;
		}
		return $Child;
	}
1130711
public function remove($entity)
    {
        //Get meta information
        $meta = $this->getMeta($entity);

        //Get a hash of this entity
        $hash = $this->getHash($entity);

        if($meta instanceof NodeMeta)
        {
            $this->nodeEntitiesToRemove[$hash] = $entity;
        }

        else
        {
            $this->relationEntitiesToRemove[$hash] = $entity;
        }
    }
147208
public function delete($where) {
		$this->provider('cache')->cacheClear('db', $this->getDao()->getTableName());
        $obj = null;
        if (empty($where) == false) {
            foreach ($where as $key => $value) {
                $obj = $this->getConnection()->where($key, $value);
            }
        }
        if ($obj ==  null) return false;
        return $obj->delete($this->getDao()->getTableName());
	}
754029
public function configure($what)
    {
        if (is_array($what)) {
            $options = $what;
        } elseif (is_readable($what)) {
            $options = include $what;
        } else {
            throw new Exception("Configure item '" . htmlentities($what)
                . "' is not an array nor a readable file.");
        }

        $this->config = array_merge($this->config, $options);
        return $this->config;
    }
209937
public function removeChild($Child)
	{
		$index = array_search($Child, $this->children);
		if($index!==false)
		{
			$tmp = $this->children[$index];
			if(isset($tmp->id))
				unset($this->id2index[$tmp->id]);
			if(isset($tmp->name))
				unset($this->name2index[$tmp->name]);
			unset($this->children[$index]);
			return $tmp;
		}
		return null;
	}
795267
function removeThis( $remove_childs = false )
    {
        $db = eZDB::instance();
        $db->begin();
        if ( is_array( $remove_childs ) )
        {
            foreach( $remove_childs as $event )
            {
                $event->remove();
            }
        }
        else if ( $remove_childs )
        {
            eZPersistentObject::removeObject( eZWorkflowEvent::definition(),
                                              array( "workflow_id" => $this->ID,
                                                     "version" => $this->Version ) );
        }

        $this->remove();
        $db->commit();
    }
1307899
function remove($ID, $Recursive = false)
	{
		$this->unassignRoles ( $ID );
		if (! $Recursive)
			return $this->permissions->deleteConditional ( "ID=?", $ID );
		else
			return $this->permissions->deleteSubtreeConditional ( "ID=?", $ID );
	}
1100658
function remove($ID, $Recursive = false)
	{
		$this->unassignPermissions ( $ID );
		$this->unassignUsers ( $ID );
		if (! $Recursive)
			return $this->roles->deleteConditional ( "ID=?", $ID );
		else
			return $this->roles->deleteSubtreeConditional ( "ID=?", $ID );
	}
41358
public static function delete($table, $where = null) {
        if ($where) {
            Delete::delete($table, $where);
        } else {
            return Delete::table($table);
        }
        return null;
    }
309427
private function removeConfig($name)
    {
        try {
            $this->configFactory->getEditable($name)->delete();
        } catch (\Exception $e) {
            throw new RuntimeException($e->getMessage());
        }
    }
1373111
public function remove($key)
    {
        if ($this->has($key)) {
            return wincache_ucache_delete($key);
        } else {
            throw new RuntimeException(sprintf(
                'Attempted to delete non-existing key "%s"', $key
            ));
        }
    }
9001
public function remove($key, $when = self::NEXT)
    {
        $deleteWhen = $when == self::ALL ? self::$when : (array) $when;
        foreach ($deleteWhen as $when) {
            $this->set($key, null, $when);
        }

        return $this;
    }