Forget data in cache behind caller with specified parameters.

@param string $caller
@param array  $parameters

@return bool
176984
public function forget($caller, array $parameters = [])
    {
        $cacheKey = $this->cacheKey($caller, $parameters);

        if ($caller == 'delete') {
            $this->repository->mediator->database($caller, $parameters);
        }

        return $this->cache()->forget($cacheKey);
    }
889924
public function setParameters(array $parameters)
    {
        $this->clearCachedValueIf($this->params != $parameters);
        $this->params = $parameters;
    }
700661
public function delete($endpoint, array $parameters = array())
    {
        return $this->execute("DELETE", sprintf("%s%s", $this->host, $endpoint) . "/", $parameters);
    }
1073816
public function delete($parameters = [])
    {
        if (!is_array($parameters)) {
            if (func_num_args() !== 1) {
                $parameters = func_get_args();
            }

            $this->deleteByPrimaryKey($parameters);

            return;
        }

        $relations = $this->entity->getRelations();

        if (empty($relations)) {
            $this->manager->postPendingQuery(
                new PendingQuery(
                    $this->entity,
                    PendingQuery::TYPE_UPDATE,
                    $this->applyFilters(
                        $this->queryBuilder->delete($this->entity->getTable())
                    ),
                    $this->parameters
                )
            );
        } else {
            $this->deleteRecords(
                $this->with(array_keys($relations))
                     ->get(array_merge($this->parameters, $parameters))
            );
        }
    }
170581
public function getCallerPermissions(Caller $caller)
    {
        $key = $this->getCallerKey($caller);

        return array_key_exists($key, $this->permissions) ? $this->permissions[$key] : [];
    }
636523
public function delete($parameter = null) {

        if ( is_null($parameter) ) {

            $this->parameters = [];
            return true;

        }

        $parts = self::splitParts($parameter);

        if ( empty($parts) ) throw new InvalidArgumentException("Invalid parameter $parameter");

        return $this->deleteFromParts($parts);

    }
723571
public function execute($parameters = null)
    {
        $this->connection->getProfiler()->start();

        return parent::execute($parameters);
    }
1049714
public function trigger( $key, $caller = NULL, $arguments = NULL ){
		if( !( $events = $this->getBoundEvents( $key, TRUE ) ) )
			return NULL;
		$this->removeStopMark( $key );
		foreach( $events as $callback ){
			if( in_array( $key, $this->stopped ) )
				continue;
			$event	= new ADT_Event_Data( $this );
			$event->key			= $callback[0];
			$event->trigger		= $key;
			$event->caller		= $caller;
			$event->data		= $callback[1]->getData();
			$event->arguments	= $arguments;
			$result			= call_user_func( $callback[1]->getCallback(), $event );
			if( $result === FALSE )
				return FALSE;
		}
		return TRUE;
	}
1107062
public function forget($key)
    {
        if (is_array($key)) {
            return $this->forgetMany($key);
        }

        return parent::forget($key);
    }
477738
def cancel(self, caller):
        
        for o in {i for i in self.children if isinstance(i, AbstractCallable)}:
            o.cancel(caller)
1254978
def delete_param(key)
      code, message, value = @server.call("deleteParam", @caller_id, key)
      case code
      when 1
        return true
      else
        return false
      end
    end
1332947
public function isOk($caller = null) {
		foreach ($this->conditions as $condition) {
			if (!$condition->isOk($caller)) {
				return false;
			}
		}
		return true;
	}
796946
public function forget($keys)
	{
		if( ! is_array($keys) )
		{
			if( func_num_args() == 1 )
			{
				$this->offsetUnset($keys);
				return $this;
			}
			else
			{
				$keys = func_get_args();
			}
		}

		foreach($keys as $name)
		{
			$this->offsetUnset($name);
		}

		return $this;
	}
305095
public function forget($key)
	{
		$this->checkLoaded();
		$this->modified = true;

		if ( $this->has($key) ) {
			SettingsUtilities::forget($this->storage, $key);
		}

		return true;
	}
34355
public function cacheKey($caller, array $parameters = [])
    {
        $parameters = compact('caller', 'parameters');

        if ($this->repository->model instanceof Eloquent || $this->repository->model instanceof Builder) {
            $parameters['eager'] = md5(serialize($this->repository->with));
        }

        if ($this->repository->mediator->criteria()->hasCriteria()) {
            $parameters['criteria'] = md5(serialize($this->repository->mediator->criteria()->getCriterias()));
        }

        return md5(serialize($parameters));
    }
487651
public function &call($type, $method, $parameters = array())
	{
		$class = $this->get_class($type);

		if (in_array($class, $this->legacy))
		{
			switch ($type)
			{
				case 'Cache':
					// For backwards compatibility with old non-static
					// Cache::create() methods
					if ($method === 'get_handler')
					{
						$result = @call_user_func_array(array($class, 'create'), $parameters);
						return $result;
					}
					break;
			}
		}

		$result = call_user_func_array(array($class, $method), $parameters);
		return $result;
	}
453765
public function removeCall(Call $call)
    {
        $newQueue = new \SplQueue();
        while (!$this->callQueue->isEmpty()) {
            $c = $this->callQueue->dequeue();

            if ($c === $call)
                continue;

            $newQueue->enqueue($c);
        }
        $this->callQueue = $newQueue;

        $registration = $call->getRegistration();
        if ($registration) {
            $registration->removeCall($call);
        }
    }