Removes a previously set type preference

@param  string    $interfaceOrAbstract
@param  string    $preferredType
@return bool|self
322814
public function removeTypePreference($interfaceOrAbstract, $preferredType)
        {
            $key = ($this->hasAlias($interfaceOrAbstract)) ? 'alias:' . $interfaceOrAbstract : $interfaceOrAbstract;

            if (!isset($this->typePreferences[$key]) || !Arrays::in($preferredType, $this->typePreferences[$key])) {
                return false;
            }

            unset($this->typePreferences[$key][array_search($key, $this->typePreferences)]);

            return $this;
        }
393340
protected function removeHandler($type, $name, $handlerName, $priority)
    {
        // If the event isn't set we add an array to the events array
        if (!isset($this->handlers[$type][$name][$priority])) {
            return;
        }
        
        // If the event handler isn't registred we return with true.
        if (!in_array($handlerName, $this->handlers[$type][$name][$priority])) {
            return;
        }
        
        // Remove the event handler from the array
        $index = array_search($handlerName, $this->handlers[$type][$name][$priority]);
        unset($this->handlers[$type][$name][$priority][$index]);
        $this->saveHandlers();
    }
349715
protected function prefers($type = null) {
		if ($type === null) {
			$prefers = 'object';
			if (!empty($this->_stub['iframe-player']) && $this->config['prefer'] === 'iframe') {
				$prefers = 'iframe';
			}
			return $prefers;
		}
		$this->config['prefer'] = $type;
		return $this;
	}
1291208
public function removeResourceType($type)
    {
        if ($this->hasResourceType($type)) {
            $namespace = $this->_resourceTypes[$type]['namespace'];
            unset($this->_components[$namespace]);
            unset($this->_resourceTypes[$type]);
        }
        return $this;
    }
88435
public function get($type, array $default = [], $remove = true)
    {
        if ($this->has($type)) {
            if (true === $remove) {
                unset($this->messages[$type]);
            }

            return $this->messages[$type];
        }

        return $default;
    }
304981
public function removeMappedType($type)
    {
        if (!$this->hasMappedType($type)) {
            throw PlatformException::mappedTypeDoesNotExist($type);
        }

        unset($this->mappedTypes[$type]);
    }
40088
public function hasTypePreferences($interfaceOrAbstract)
        {
            $key = ($this->hasAlias($interfaceOrAbstract)) ? 'alias:' . $interfaceOrAbstract : $interfaceOrAbstract;

            return (isset($this->typePreferences[$key]) && $this->typePreferences[$key]);
        }
740121
public function removeType(Type $type) {
        if (!isset(self::$hasSubtypes[$this->type])) {
            if ($this->equals($type)) {
                // left with an unknown type
                return Type::null();
            }
            return $this;
        }
        $new = [];
        foreach ($this->subTypes as $key => $st) {
            if (!$st->equals($type)) {
                $new[] = $st;
            }
        }
        if (empty($new)) {
            throw new \LogicException('Unknown type encountered');
        } elseif (count($new) === 1) {
            return $new[0];
        }
        return new Type($this->type, $new);
    }
50367
public function removeTemplateEntity(
        ?TemplateEntityInterface $templateEntity = null,
        bool $recip = true
    ): self {
        if (
            $this instanceof ReciprocatesTemplateEntityInterface
            && true === $recip
        ) {
            if (!$templateEntity instanceof EntityInterface) {
                $templateEntity = $this->getTemplateEntity();
            }
            $remover = 'remove' . self::getDoctrineStaticMeta()->getSingular();
            if (false !== method_exists($templateEntity, $remover)) {
                $templateEntity->$remover($this, false);
            }
        }

        return $this->setTemplateEntity(null, false);
    }
1071870
public function removeDisallowedType($type)
    {
        if (in_array(strtolower($type), $this->disallowedTypes)) {
            unset($this->disallowedTypes[array_search(strtolower($type), $this->disallowedTypes)]);
        }
        return $this;
    }
328086
public function removeInterface($interface) {
		if ($interface instanceof PhpInterface) {
			$name = $interface->getName();
			$qname = $interface->getQualifiedName();

			$this->removeUseStatement($qname);
		} else {
			$name = $interface;
		}

		$this->interfaces->remove($name);

		return $this;
	}
415512
public function remove(SharedLinkType $sharedLinkType): bool
    {
        $uri = sprintf(
            '%s/shared-links/?t=%s',
            $this->clipUri($this->client->getConfig('base_uri')),
            basename($sharedLinkType->url)
        );

        $response = $this->client->request(
            'DELETE',
            $uri,
            [
                'headers' => ['Accept' => 'application/json'],
            ]
        );

        return $response->getStatusCode() === 200;
    }
589706
public static boolean removeFiles(String destinationType) {
		LogRepositoryManager destManager = getManager(destinationType) ;
		if (destManager instanceof LogRepositoryManagerImpl)
			return destManager.purgeOldFiles() ;
		else
			return false ;
	}
1227630
private static void removeDuplicateContracts(final Class<?> type, final Set<Class<?>> contracts) {
        if (contracts.isEmpty()) {
            return;
        }

        // remove interfaces already included in common type (e.g. Number and Serializable)
        Iterator<Class<?>> it = contracts.iterator();
        while (it.hasNext()) {
            if (it.next().isAssignableFrom(type)) {
                it.remove();
            }
        }

        // remove duplicate interfaces (e.g. List already include Collection and Iterable)
        it = contracts.iterator();
        while (it.hasNext()) {
            final Class<?> current = it.next();
            for (Class<?> iface : contracts) {
                if (!current.equals(iface) && current.isAssignableFrom(iface)) {
                    it.remove();
                    break;
                }
            }
        }
    }
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)));
    }
1072507
public void delist(BeanO beanO)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "delist : " + beanO);
        ensureActive();
        ivBeanOs.remove(beanO.beanId); // d130022
        ivBeanOList.remove(beanO); // d130022

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "delist : " + beanO);
    }
1222764
protected void deleteTypeVertex(AtlasVertex instanceVertex, DataTypes.TypeCategory typeCategory, boolean force) throws AtlasException {
        switch (typeCategory) {
        case STRUCT:
        case TRAIT:
            deleteTypeVertex(instanceVertex, force);
            break;

        case CLASS:
            deleteEntities(Collections.singletonList(instanceVertex));
            break;

        default:
            throw new IllegalStateException("Type category " + typeCategory + " not handled");
        }
    }