Clear item from cache

@param  mixed $id
@param  mixed $type

@return void
428951
public function forget($key, $type)
	{
		if(is_array($key))
		{
			return $this->forgetItem($this->storageKey($key), $type);
		}

		if(is_string($key))
		{
			return $this->forgetItem($key, $type);
		}

		if(is_int($key))
		{
			return $this->forgetItem($this->storageKey([$key]), $type);
		}
	}
205617
protected function removeAllItems($type)
    {
        if (!$this->supportsCascadeUpdate()) {
            $names = (new Query)
                ->select(['name'])
                ->from($this->itemTable)
                ->where(['type' => $type])
                ->column($this->db);
            if (empty($names)) {
                return;
            }
            $key = $type == Item::TYPE_PERMISSION ? 'child' : 'parent';
            $this->db->createCommand()
                ->delete($this->itemChildTable, [$key => $names])
                ->execute();
            $this->db->createCommand()
                ->delete($this->assignmentTable, ['item_name' => $names])
                ->execute();
        }
        $this->db->createCommand()
            ->delete($this->itemTable, ['type' => $type])
            ->execute();

        $this->_assignments = [];
        $this->_children = $this->_items = null;

        $this->invalidate(static::PART_ITEMS);
        $this->invalidate(static::PART_CHILDREN);
    }
1176736
public function wipe($type) {
		$table = $type;
		$table = $this->safeTable($table);
		$sql = "TRUNCATE $table CASCADE";
		$this->adapter->exec($sql);
	}
103195
public function remove($id)
    {
        $this->client->delete(Inflector::pluralize($this->getResourceName()).'/'.$id);
    }
403276
public function remove($id)
    {
        $id   = $this->validateAndResolveId($id);
        $path = $this->items[$id][self::PATH];

        // remove item from hierarchy
        $this->hierarchy->remove($path);
        // remove item
        unset($this->items[$id]);
        $this->aliases->removeById($id);
        unset($this->blockThemes[$id]);
        // remove all children
        $pathLength    = count($path);
        $pathLastIndex = $pathLength - 1;
        $ids           = array_keys($this->items);
        foreach ($ids as $itemId) {
            $currentPath = $this->items[$itemId][self::PATH];
            if (count($currentPath) > $pathLength && $currentPath[$pathLastIndex] === $id) {
                unset($this->items[$itemId]);
                $this->aliases->removeById($itemId);
                unset($this->blockThemes[$itemId]);
            }
        }
    }
601113
public function clear( $type = null ) 
	{
		if ( is_null( $type ) )
		{
			$this->assets = array();
		}
		else
		{
			if ( isset( $this->assets[$type] ) )
			{
				$this->assets[$type] = array();
			}
		}
	}
281599
public function delete($type = null, $id = null)
    {
        $this->_validateActionIsEnabled('delete');

        $this->_event('beforeDelete', [
            'id' => $id
        ]);

        $entity = $this->Model->get($id);

        $this->request->allowMethod(['post', 'delete']);

        if ($this->Model->delete($entity)) {
            $this->Flash->success(__d('CakeAdmin', 'The {0} has been deleted.', [$this->type['singularAliasLc']]));
        } else {
            $this->Flash->error(__d('CakeAdmin', 'The {0} could not be deleted. Please, try again.', [$this->type['singularAliasLc']]));
        }

        $this->_event('afterDelete', [
            'id' => $id
        ]);

        return $this->redirect(['action' => 'index', 'type' => $this->type['name']]);
    }
280137
public static function cleanCache($id, $parentOld)
    {
        unset(static::$_children[$parentOld]);
        unset(static::$_nodes[$id]);
        unset(static::$_i18n[$id]);

        $node = static::node($id);
        if (!empty($node)) {
            unset(static::$_children[$node->parent_id]); // after update node can get new parent
        }
    }
654886
public function clear() {
		unset( self::$stack[ $this->type ][ $this->id ] );
		if( empty( self::$stack[ $this->type ] ) ){
			unset( self::$stack[ $this->type ] );
		}
		$this->id = null;
	}
872045
public void deleteById(String id) {
    if (idToVersion.containsKey(id)) {
      String version = idToVersion.remove(id);
      expirationVersion.remove(version);
      versionToItem.remove(version);
      if (collectionCachePath != null
          && !collectionCachePath.resolve(version).toFile().delete()) {
        log.debug("couldn't delete " + version);
      }
    }
  }
939031
private function deleteById($id)
    {
        $builder = $this->repository->createQueryBuilder();
        $builder
            ->remove()
            ->field('id')->equals($id)
            ->getQuery()
            ->execute();
    }
916521
public static function clearCache(&$config, $type = "all") {
		$cacheDirectories = self::checkCache ( $config );
		$cacheDirs = [ "annotations","controllers","models","queries","views","contents" ];
		foreach ( $cacheDirs as $typeRef ) {
			self::_clearCache ( $cacheDirectories, $type, $typeRef );
		}
	}
686890
public function removeItem($class, $id)
    {
        $this->loadFromCookies();
        if (!isset($this->items[$class]))
        {
            return;
        }

        unset($this->items[$class][$id]);
        $this->saveToCookies();
    }
939962
public function deleteTable($id)
    {
        if (isset($this[$id])) {
            Common::destroy($this[$id]);
            $this->setTableDeleted($id);
        }
    }
253236
public function problem($id, $type = 'id')
    {
        $problem = $this->load('p', array($type, $id));

        return Helper\formatProblem($problem);
    }
1362896
public function set_caching($type)
    {
        if ($type) {
            $this->caching = $type;
        }
        else {
            if ($this->cache) {
                $this->cache->close();
            }
            $this->cache   = null;
            $this->caching = false;
        }
    }
1031002
public function delete_object( $type, $id, $name = null ) {

		if ( empty( $name ) ) {
			$name = $type;
		}

		$object = $this->object_get( $type, $name );

		if ( ! empty( $object ) ) {
			$params = array(
				'pod'    => pods_var( 'name', $object ),
				'pod_id' => pods_var( 'id', $object ),
				'id'     => $id
			);

			return pods_api()->delete_pod_item( $params, false );
		} else {
			return pods_api()->delete_object_from_relationships( $id, $type, $name );
		}
	}