Remove specified blame.
@param {$this->multiBlamesClass}|string $blame
@return false|array all guids in json format.
775370
public function removeBlame($blame)
    {
        if (!is_string($this->multiBlamesAttribute)) {
            return false;
        }
        $blameGuid = '';
        if (is_string($blame)) {
            $blameGuid = $blame;
        }
        if ($blame instanceof $this->multiBlamesClass) {
            $blameGuid = $blame->getGUID();
        }
        $blameGuids = $this->getBlameGuids(true);
        if (($key = array_search($blameGuid, $blameGuids)) !== false) {
            unset($blameGuids[$key]);
            $this->setBlameGuids($blameGuids);
        }
        return $this->getBlameGuids();
    }
1186377
public static function unsetInvalidGUIDs($guids)
    {
        foreach ($guids as $key => $guid)
        {
            if (!preg_match(self::GUID_REGEX, $guid)){
                unset($guids[$key]);
            }
        }
        return $guids;
    }
638064
public function remove($id)
    {
        if (true === $result = @unlink($this->getCacheFile($id))) {
            $this->log('debug', sprintf('Cache data removed for id `%s`.', $id));
        }

        return $result;
    }
1228231
public function remove()
    {
        $f = json_decode(file_get_contents(FEnv::get("framework.root").
            "elements/config_files/core/apps.json"));
        foreach ($f as $one => $val) {
            if ($val->name == $this->name) {
                unset($f->$one);
                break;
            }
        }

        $f = json_encode($f, JSON_PRETTY_PRINT);
        file_put_contents(FEnv::get("framework.root")."elements/config_files/core/apps.json", $f);

        Server::delete(FEnv::get("framework.root")."apps/".$this->name, "directory");
        Server::delete(
            FEnv::get("framework.root")."public/components/apps/".strtolower($this->name),
            'directory'
        );
    }
1117474
public function remove($id)
    {
        if (false === $this->_cache->delete($id)) {
            return $this->_onError('remove');
        }

        return true;
    }
328738
public function delete($source=null) {
        global $DB;
        if (!empty($this->courseid)) {
            $DB->delete_records('grade_outcomes_courses', array('outcomeid' => $this->id, 'courseid' => $this->courseid));
        }
        if (parent::delete($source)) {
            $context = context_system::instance();
            $fs = get_file_storage();
            $files = $fs->get_area_files($context->id, 'grade', 'outcome', $this->id);
            foreach ($files as $file) {
                $file->delete();
            }
            return true;
        }
        return false;
    }
1349976
public function remove($id)
    {
        try {
            if ($this->softDelete) {
                $removed = [];
                $removed[$this->primaryKey] = $id;
                $removed[$this->softDeleteName] = date('Y-m-d H:i:s');

                $this->save($removed);
            } else {
                $this->db->delete($this->table, array(
                    $this->primaryKey => $id
                ));
            }

            return true;
        } catch (\Exception $e) {
            return false;
        }
    }
32674
public function destroy($id)
    {
        $ids = explode(',', $id);

        foreach ($ids as $id) {
            if (empty($id)) {
                continue;
            }
            $this->deleteFilesAndImages($id);
            $this->model->find($id)->delete();
        }

        return true;
    }
364898
public function removeMany(array $ids) {
		$backend = $this->getBackend();
		$ids     = array_map([$this, 'prepareId'], $ids);
		
		$result = true;
		
		try {
			foreach ($ids as $id) {
				if (! $backend->delete($id)) {
					$result = false;
				}
			}
		} catch (PhalconCacheException $exception) {
			if ($this->operationsExceptions) {
				throw new OperationFailed('Removing of the data from the cache failed due to the backend exception occurred: "' . $exception->getMessage() . '"', 0, $exception);
			} else {
				return false;
			}
		}
		
		return $result;
	}
307220
public function destroy()
    {
        try {
            $ids = func_get_args();
            $id = end($ids);
            $this->service->destroy($id);

            return $this->response()->noContent();
        } catch (ValidationException $e) {
            throw new DeleteResourceFailedException('Delete failed', $e->getValidationErrors());
        } catch (DomainException $e) {
            throw new DeleteResourceFailedException('Delete failed', [$e->getMessage()]);
        }
    }
179536
public final function remove()
    {
        if ($this->exists())
        {
            if (unlink($this->getPath()))
                return true;
            throw new \Exception($this->getName() . ': Deleting failed');
        }
    }
265952
public function addBlame($blame)
    {
        if (!is_string($this->multiBlamesAttribute)) {
            return false;
        }
        $blameGuid = '';
        if (is_string($blame)) {
            $blameGuid = $blame;
        }
        if ($blame instanceof $this->multiBlamesClass) {
            $blameGuid = $blame->getGUID();
        }
        $blameGuids = $this->getBlameGuids(true);
        if (array_search($blameGuid, $blameGuids)) {
            throw new InvalidParamException('the blame has existed.');
        }
        if ($this->getBlamesCount() >= $this->blamesLimit) {
            throw new InvalidCallException("the limit($this->blamesLimit) of blames has been reached.");
        }
        $blameGuids[] = $blameGuid;
        $this->setBlameGuids($blameGuids);
        return $this->getBlameGuids();
    }
296230
public static function getBlame($blameGuid)
    {
        $self = static::buildNoInitModel();
        if (empty($blameGuid) || empty($self->multiBlamesClass) ||
            !is_string($self->multiBlamesClass) || $self->multiBlamesAttribute === false) {
            return null;
        }
        $mbClass = $self->multiBlamesClass;
        return $mbClass::findOne($blameGuid);
    }
295388
public function destroy($iId)
    {
        if (empty($iId)) {
            $this->setError('Event ID not defined.');
            return false;
        }

        // -------------------------------------------------------------------------

        //  Perform delete
        $oDb = Factory::service('Database');
        $oDb->where('id', $iId);
        $oDb->delete($this->sTable);

        if ($oDb->affected_rows()) {
            return true;
        } else {
            $this->setError('Event failed to delete');
            return false;
        }
    }
221025
public function destroy($id)
    {
        $return = false;

        if ($this->delete($this->_getPrimary($id, self::PRIMARY_TYPE_WHERECLAUSE))) {
            $return = true;
        }

        return $return;
    }
1131462
public function removeDiagnostic($id)
    {
        $ids = $id ? $id : [];
        if (! is_array($ids)) {
            $ids = [$ids];
        }

        foreach($ids as $id) {
            $this->getStorage()->delete($id);
        }

        return true;
    }
1191631
public static function removeRecognition(string $name): bool
    {
        if (isset(self::$recognitions[$name])) {
            unset(self::$recognitions[$name]);
            return true;
        }

        return false;
    }