Removes a link from a link-set|list.

@param  array   $updates
@param  string  $class
@param  boolean $append
@return Remove
175566
public function remove(array $updates, $class, $append = true)
    {
        $commandClass = $this->getCommandClass('update.remove');
        $this->command = new $commandClass($updates, $class, $append);

        return $this->command;
    }
900009
function removeAttributes( $removeAttributes = false, $version = false )
    {
        if ( is_array( $removeAttributes ) )
        {
            $db = eZDB::instance();
            $db->begin();
            foreach( $removeAttributes as $attribute )
            {
                $attribute->removeThis();
            }
            $db->commit();
        }
        else
        {
            $contentClassID = $this->ID;

            if ( $version === false )
            {
                $version = $this->Version;
            }
            $classAttributes = $this->fetchAttributes( );

            $db = eZDB::instance();
            $db->begin();
            foreach ( $classAttributes as $classAttribute )
            {
                $dataType = $classAttribute->dataType();
                if ( $dataType === null )
                {
                    eZDebug::writeError(
                        "Skipping removal of class attribute for non-existent datatype " . $classAttribute->DataTypeString,
                        __METHOD__
                    );
                    continue;
                }
                $dataType->deleteStoredClassAttribute( $classAttribute, $version );
            }
            eZPersistentObject::removeObject( eZContentClassAttribute::definition(),
                                              array( 'contentclass_id' => $contentClassID,
                                                     'version' => $version ) );
            $db->commit();
        }
    }
1127571
public function removeClass($class)
    {
        $this->setOption(self::OPTION_METHOD, "removeClass");
        $this->setOption(self::OPTION_REMOVE_CLASS, $class);

        return $this;
    }
211191
public function remove(string $commit, array $params = [])
    {
        $path = $this->buildFilesPath($commit);

        return $this->delete($path, $params);
    }
49706
public function removeAppends($appends)
	{
		if (is_string($appends)) {
			$appends = func_get_args();
		}

		$this->appends = array_diff($this->appends, $appends);

		return $this;
	}
1375040
protected function notPublishGroupAction($class)
    {
        try {
            if ( ! $class::whereIn('id', $this->request->id)->update(['is_publish' => false])) {
                throw new UpdateException($this->request->id, 'group not not published');
            }
            event(new $this->events['success']($this->request->id));
            return true;
        } catch (UpdateException $e) {
            event(new $this->events['fail']($e->getDatas()));
            return false;
        }
    }
1182333
public function removeAttributeClass($classes)
    {
        if ($this->offsetExists('class')) {
            if (is_string($classes)) {
                $classes = explode(',', $classes);
            }

            $classes = array_map('trim', $classes);
            $classes = array_filter($classes);

            foreach ($classes as $class) {
                if (false !== ($key = array_search($class, $this->storage[ 'class' ]))) {
                    unset($this->storage[ 'class' ][ $key ]);
                } elseif (strpos($class, '*') !== false) {
                    $class = str_replace('*', '', $class);
                    foreach ($this->storage[ 'class' ] as $key => $value) {
                        if (preg_match("/\b$class\b/i", $value)) {
                            unset($this->storage[ 'class' ][ $key ]);
                        }
                    }
                }
            }

            if (count($this->storage[ 'class' ]) == 0) {
                unset($this->storage[ 'class' ]);
            }
        }
    }
592758
public function append($append = [], $override = false)
    {
        $this->each(function ($model) use ($append, $override) {
            /** @var Model $model */
            $model && $model->append($append, $override);
        });

        return $this;
    }
905920
public static function remove($source)
    {
        if (!is_file($source)) {
            return false;
        }
        try {
            @unlink($source);
            return true;
        } catch (\Exception $e) {
            return false;
        }
    }
1362080
public function remove_callable($class)
	{
		if (($key = array_search($class, $this->callables, true)))
		{
			unset($this->callables[$key]);
		}

		return $this;
	}
344290
@Override
    public void removeAppender(Appender appender) {
        if (appender == null || aai == null) {
            return;
        }
        boolean wasAttached = aai.isAttached(appender);
        aai.removeAppender(appender);
        if (wasAttached) {
            fireRemoveAppenderEvent(appender);
        }
    }
271
public function removeAttachmentJoins()
    {
        $joinProto = $this->modelFactory()->get(Join::class);

        $loader = $this->collectionLoader();
        $loader
            ->setModel($joinProto)
            ->addFilter('object_type', $this->objType())
            ->addFilter('object_id', $this->id());

        $collection = $loader->load();

        foreach ($collection as $obj) {
            $obj->delete();
        }

        return true;
    }
730854
public function removeOrganizationsAction($id, $class, Request $request)
    {
        $object = $this->find($class, $id);
        $organizations = $this->decodeIdsString($request, 'Claroline\CoreBundle\Entity\Organization\Organization');
        $this->crud->patch($object, 'organization', Crud::COLLECTION_REMOVE, $organizations);

        return new JsonResponse(
              $this->serializer->serialize($object)
          );
    }
398229
public function addAppends($appends)
	{
		if (is_string($appends)) {
			$appends = func_get_args();
		}

		$this->appends = array_merge($this->appends, $appends);

		return $this;
	}
948756
public function remove($append_uri = null) {
        if ($this->read_only) {
            throw new ReadOnly("The entity is read-only");
        }

        $this->setTokenValue($this->getEntityIdName(), $this->getId());
        $this->delete(null, $append_uri);
        $this->reset();
        return $this;
    }
98820
public function remove_column($class)
    {
        // Remove the header
        foreach ($this->header as $index => $header){
            if ($header->attrib['class'] == $class){
                unset($this->header[$index]);
                break;
            }
        }

        // Remove cells from rows
        foreach ($this->rows as $i => $row){
            foreach ($row->cells as $j => $cell){
                if ($cell->attrib['class'] == $class){
                    unset($this->rows[$i]->cells[$j]);
                    break;
                }
            }
        }
    }
559817
private boolean removeUpdate() throws IOException, ServletException {
	final File patchDir = getPatchDirectory();
	final File[] patches = patchDir.listFiles(new ExtensionFilter(new String[] { "rc", "rcs" }));

	for (int i = 0; i < patches.length; i++)
	    if (!patches[i].delete()) patches[i].deleteOnExit();
	_restart();
	return true;
    }