Unset type preferences

@param  string $interfaceOrAbstract
@return void
340185
public function unsetTypePreferences($interfaceOrAbstract)
        {
            $key = ($this->hasAlias($interfaceOrAbstract)) ? 'alias:' . $interfaceOrAbstract : $interfaceOrAbstract;

            unset($this->typePreferences[$key]);
        }
1189515
def unset(entity, *types):
    
    if not types:
        types = (TypedField,)

    fields = list(entity._fields.keys())
    remove = (x for x in fields if isinstance(x, types))

    for field in remove:
        del entity._fields[field]
373688
public function resetReportTypes(){
        foreach($this->options as $op=>$junk){
            if(preg_match("#ReportTypeList#",$op)){
                unset($this->options[$op]);
            }
        }
    }
328935
public function removeType($type)
    {
        foreach ($this->fields as $fieldname => $field) {
            if ($field->type == $type) {
                unset($this->fields[$fieldname]);
            }
        }
        foreach ($this->button_container as $container => $buttons) {
            foreach ($buttons as $key=>$button) {
                if (strpos($button, 'type="'.$type.'"')!==false) {
                    $this->button_container[$container][$key] = "";
                }
            }
        }

        return $this;
    }
492005
public function unserialize($serializedObject)
    {
        $objectVars = unserialize($serializedObject);

        foreach ($objectVars as $key => $value) {
            $this->{$key} = $value;
        }
    }
267363
public function detachAll($type = null)
    {
        if ($type === null) {
            $this->listeners = [];
        } else {
            if (isset($this->listeners[$type])) {
                unset($this->listeners[$type]);
            }
        }
    }
1239142
public function remove(TypeInterface $typeToRemove)
    {
        foreach ($this->collection as $key => $type) {
            if ($type === $typeToRemove) {
                unset($this->collection[$key]);

                return;
            }
        }

        throw new \RuntimeException(\sprintf('Cannot remove given type %s', \var_export($typeToRemove, true)));
    }
67431
public function removeRecursive($objElement)
    {
        foreach ($this->collection as $intKey => $objValue) {
            if ($objValue->hasFields()) {
                $objValue->getFields()->removeRecursive($objElement);
            } else {
                if ($objValue->getName() == $objElement->getName()) {
                    unset($this->collection[$intKey]);
                }
            }
        }
    }
1312976
public function remove($object)
    {
        if (!is_object($object) || !($object instanceof $this->objectType)) {
            $type = (is_object($object) ? get_class($object) : gettype($object));
            throw new IllegalObjectTypeException('The value given to remove() was ' . $type . ' , however the ' . get_class($this) . ' can only handle ' . $this->objectType . ' instances.', 1517408067);
        }
        $this->entityManager->remove($object);
    }
29810
public function setByType($type)
    {
        if (isset(self::$sourceList[$type])) {
            $this->value = self::$sourceList[$type];
        } else {
            throw new Exception("undefined index $type");
        }
    }
380544
public function unlinkDisownedObjects()
    {
        $object = $this->getObjectInStage(Versioned::DRAFT);
        if ($object) {
            $object->unlinkDisownedObjects($object, Versioned::LIVE);
        }
    }
600575
public function unsetHandler($type, \fpoirotte\Pssht\HandlerInterface $handler)
    {
        if (!is_int($type) || $type < 0 || $type > 255) {
            throw new \InvalidArgumentException();
        }

        if (isset($this->handlers[$type]) && $this->handlers[$type] === $handler) {
            unset($this->handlers[$type]);
        }
        return $this;
    }
1277503
private function popTokens($typeMask = null)
    {
        while ($this->isTopStackToken($typeMask)) {
            $token = $this->stack->pop();
            if ($token->type & self::$tokenShortcuts['operatorUnary']) {
                $this->addCorrection(
                    self::CORRECTION_UNARY_OPERATOR_MISSING_OPERAND_IGNORED,
                    $token
                );
            } else {
                $this->addCorrection(
                    self::CORRECTION_BINARY_OPERATOR_MISSING_RIGHT_OPERAND_IGNORED,
                    $token
                );
            }
        }
    }
883113
public function offsetUnset($offset)
    {
        if(is_array($this->obj)){
            unset($this->obj[$offset]);
        }elseif(self::hasProperty($this->obj, $offset)){
            unset($this->obj->{$offset});
        }elseif(method_exists($this->obj, 'remove')){
            $this->obj->remove($offset);
        }elseif(method_exists($this->obj, $method = 'remove'.ucfirst($offset))){
            $this->obj->$method();
        }else{
            throw new \InvalidArgumentException("offsetUnset($offset) failed");
        }
    }
383
public function remove(PHPExcel_IComparable $pSource = null) {
		$hash = $pSource->getHashCode();
		if (isset($this->_items[$hash])) {
			unset($this->_items[$hash]);

			$deleteKey = -1;
			foreach ($this->_keyMap as $key => $value) {
				if ($deleteKey >= 0) {
					$this->_keyMap[$key - 1] = $value;
				}

				if ($value == $hash) {
					$deleteKey = $key;
				}
			}
			unset($this->_keyMap[count($this->_keyMap) - 1]);
		}
	}
1104831
public function RemoveTypeDef($name, $namespace="", $header="")
    {
        if($header)
        {
            if($namespace)
            {
                unset($this->headers[$header]->namespaces[$namespace]->type_definitions[$name]);
            }
            else
            {
                foreach($this->headers[$header]->namespaces as $namespace_object)
                {
                    unset($namespace_object->type_definitions[$name]);
                }
            }
        }
        elseif($namespace)
        {
            foreach($this->headers as $header_object)
            {
                unset($header_object->namespaces[$namespace]->type_definitions[$name]);
            }
        }
        else
        {
            foreach($this->headers as $header_object)
            {
                foreach($header_object->namespaces as $namespace_object)
                {
                    unset($namespace_object->type_definitions[$name]);
                }
            }
        }
    }
1367829
function offsetUnset($name)
    {
        $v = $this->getValue();
        if (is_array($v) && $this->offsetExists($name)){
            if (isset($this->_interfaces[$name])){
                $this->_interfaces[$name]->_maker = null;
                unset($this->_interfaces[$name]);
            }
            unset($v[$name]);
            $this->set($v);
        }
    }