Unsets a parameter or an object.

@param string $reference The unique identifier for the parameter or object
493480
public function offsetUnset($reference)
    {
        $reference = $this->mapReference($alias);

        //Remove the reference from the container;
        unset($this->container[$reference]);

        //Remove its aliases;
        while (($alias = array_search($reference, $this->aliases)) !== null) {
            unset($this->aliases[$alias]);
        }

    }
405386
public function prune($reference = null)
    {
        if ($reference) {
            $this->addUsingAlias(ReferenceTableMap::COL_ID, $reference->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
1352558
public function offsetUnset($offset)
	 {
		 $value = isset ($this->data[$offset]) ? $this->data[$offset] : null;
		 unset ($this->data[$offset]);
		 $this->trigger ('unset', $value, $offset);
	 }
598121
public function remove($key)
    {
        if (!is_string($key) && !is_numeric($key)) {
            throw new InvalidArgumentException(
                'Invalid key name given! Key config to remove must be as a string!'
            );
        }

        if (!$this->exist($key)) {
            return;
        }

        if (($count = preg_match_all('/(?:^[^\[]+)|\[[^]]*\]/', $key, $matches)) > 1) {
            $firstKey = reset($matches[0]);
            $keyName  = $firstKey;
            $tmp      = $this->collection[$keyName];
            if (!is_array($tmp)) {
                return;
            }
            array_shift($matches[0]);
            $unsetPosition = 0;
            foreach ($matches[0] as $keyNum => $keyName) {
                $keyName = trim($keyName, '[]');
                if ($unsetPosition <> $keyNum &&
                    (!is_array($tmp) || ! array_key_exists($keyName, $tmp))
                ) {
                    return;
                }

                $unsetPosition++;
                $tmp = $tmp[$keyName];
            }

            $tmp = $this->collection[$firstKey];
            $currentUnsetPosition = 0;
            // binding anonymous function to handle array reference
            $recursiveUnset = function (
                &$array,
                $unwanted_key
            ) use (
                $unsetPosition,
                &$currentUnsetPosition,
                &$recursiveUnset
            ) {
                $currentUnsetPosition++;
                if ($unsetPosition !== $currentUnsetPosition) {
                    if (array_key_exists($unwanted_key, $array)) {
                        unset($array[$unwanted_key]);
                    }
                    // stop
                    return;
                }
                foreach ($array as &$value) {
                    if (is_array($value)) {
                        $recursiveUnset($value, $unwanted_key);
                    }
                }
            };

            // call closure to binding reference
            $recursiveUnset($tmp, $keyName);
            $this->collection[$firstKey] = $tmp;
            unset($tmp);
            return; // stop
        }

        unset($this->collection[$key]);
    }
537785
public function unstore($reference, $options = array())
    {
        Options::required('card_token', $options);

        $action = sprintf(self::UNSTORE, $reference, $options['card_token']);

        return $this->commit($action, RequestInterface::METHOD_DELETE);
    }
1063603
@Trivial
    public void unsetSslSupport(ServiceReference<ChannelFactoryProvider> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.entry(this, tc, "unsetSslSupport", new Object[] { ref.getProperty("type"), ref });
        }
        // see if its for the same service ref, if yes then destroy
        if (_sslFactoryProvider.getReference() == ref)
        {
            if (_isSSLChain) {
                if (_isChainStarted)
                    performAction(destroyChainAction);
            }

        }
        if (_sslFactoryProvider.unsetReference(ref)) {
            _isSSLEnabled = false;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "unsetSslSupport", _isSSLEnabled);
        }

    }
840034
private function hasIdentifier($reference)
    {
        // in case if reference is set after flush, store its identity
        $uow = $this->manager->getUnitOfWork();

        if ($this->manager instanceof PhpcrDocumentManager) {
            return $uow->contains($reference);
        } else {
            return $uow->isInIdentityMap($reference);
        }
    }
209589
public function remove($username, $repository, $reference)
    {
        $reference = $this->encodeReference($reference);

        return $this->delete('/repos/'.rawurlencode($username).'/'.rawurlencode($repository).'/git/refs/'.$reference);
    }
1330517
protected Map<String, Object> unsetAuthorization(ServiceReference<AuthorizationService> ref) {
        authorization.removeReference((String) ref.getProperty(KEY_ID), ref);
        authorization.removeReference(String.valueOf(ref.getProperty(KEY_SERVICE_ID)), ref);

        // determine a new authorization service
        authzService.set(null);
        return getServiceProperties();
    }
190379
public function offsetUnset($offset)
    {
        if (isset($this->keys[$offset])) {
            if (is_object($this->items[$offset])) {
                unset($this->factory[$this->items[$offset]],
                $this->protect[$this->items[$offset]]);
            }
            unset($this->items[$offset], $this->frozen[$offset],
            $this->raw[$offset], $this->keys[$offset]);
        }
    }
1125325
public function offsetUnset($offset)
    {
        if (strcmp($offset, $this->key()) === 0) {
            // #0002184: active element removed, next element will be prev / first
            $this->_blRemovedActive = true;
        }

        unset($this->_aArray[$offset]);
    }
842332
public function remove($key)
    {
        $method = 'remove'.$key;

        if (method_exists($this, $method)) {
            $this->$method();
        } else {
            unset($this->metas[$key]);
        }
    }
500503
public function offsetUnset($key)
    {
        unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
    }
713715
public function belongsToReference($reference)
    {
        $reference = self::trimReference($reference);
        $reference = self::normalizeReference($reference);
        return stripos($this->getReferenceDotDelimited() . '.', $reference . '.') === 0;
    }
389497
public function offsetUnset($offset)
    {
        //argument 1 must be scalar, null or bool
        Argument::i()->test(1, 'scalar', 'null', 'bool');
        
        $this->list = Model::i($this->list)
            ->cut($offset)
            ->get();
    }
1080361
public function offsetUnset($offset)
    {
        if ($this->offsetExists($offset))
        {
            $this->_modified = true;
            unset($this->_storage[$offset]);
        }
    }
919983
protected void unsetExecutor(ServiceReference<ExecutorService> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "unsetExecutor", ref);
        execSvcRef.unsetReference(ref);
    }