Removes the type converter.

@param tc the converter to remove
438993
public void removeConverter(final TypeConverter tc) {
        if (tc.getSupportedTypes() == null) {
            untypedTypeEncoders.remove(tc);
            registeredConverterClasses.remove(tc.getClass());
        } else {
            for (final Entry<Class, List<TypeConverter>> entry : tcMap.entrySet()) {
                List<TypeConverter> list = entry.getValue();
                if (list.contains(tc)) {
                    list.remove(tc);
                }
                if (list.isEmpty()) {
                    tcMap.remove(entry.getKey());
                }
            }
            registeredConverterClasses.remove(tc.getClass());
        }

    }
416068
public static void exception(TraceComponent tc, Throwable t) {
    if(isTracing()) SibTr.exception(tc, t);

  }
998516
public static final void removeTxn(Xid xid)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "removeTxn", xid);

        final ByteArray key = new ByteArray(xid.getGlobalTransactionId());

        final JCATranWrapper wrapper;

        synchronized (txnTable)
        {
            wrapper = txnTable.remove(key);
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "removeTxn", wrapper);
    }
836634
@Override
	public void removeByCP_T(long CProductId, String type) {
		for (CPDefinitionLink cpDefinitionLink : findByCP_T(CProductId, type,
				QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionLink);
		}
	}
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;
                }
            }
        }
    }
871726
public void removeComponent(Object screenField)
    {
        if (this.getNextConverter() != null)
        {
            FieldInfo field = this.getField();
            this.getNextConverter().removeComponent(screenField);
            // **START SPECIAL CODE** This code is for a specific special case.
            // This code is for the special case when one converter is used by two SFields
            // I Don't free this converter if there is still an SField pointing to me.
            if (field != null)
            {
                for (int i = 0; ; i++)
                {
                    Object screenField2 = field.getComponent(i);
                    if (!(screenField2 instanceof ScreenComponent))
                        break;      // End of loop
                    if (screenField2 != screenField)
                    {   // Okay, this field has another SField, go through the converters and make sure this one is not referenced.
                        Convert converter = ((ScreenComponent)screenField2).getConverter();
                        while ((converter != null) && (converter != field))
                        {
                            if (converter == this)
                                return;     // DO NOT Free this converter, it is referenced by another ScreenField!
                            if (converter instanceof LinkedConverter)
                                converter = ((LinkedConverter)converter).getNextConverter();
                            else
                                converter = null;
                        }
                    }
                }
            }

        }
        super.removeComponent(screenField);   // delete this
    }
372471
private static BaseTypeConverter lookupTypeConverter(Class type) {
        BaseTypeConverter converter = (BaseTypeConverter)TYPE_CONVERTERS.get(type);
        if(converter == null) {
            String msg = "Could not find a TypeConverter for converting a String to an object of type \"" +
                (type != null ? type.getName() : null) + "\"";
            TypeConverterNotFoundException tcn = new TypeConverterNotFoundException(msg);

            if(type == null)
                msg = Bundle.getErrorString("TypeUtils_nullType");
            else
                msg = Bundle.getErrorString("TypeUtils_noConverterForType", new Object[]{type.getName()});
            tcn.setLocalizedMessage(msg);
            LOGGER.error(msg);

            throw tcn;
        }

        return converter;
    }
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]
401986
def remove_alias(type_):
    
    if isinstance(type_, cpptypes.type_t):
        type_ref = type_
    elif isinstance(type_, typedef.typedef_t):
        type_ref = type_.decl_type
    else:
        # Not a valid input, just return it
        return type_
    if type_ref.cache.remove_alias:
        return type_ref.cache.remove_alias
    no_alias = __remove_alias(type_ref.clone())
    type_ref.cache.remove_alias = no_alias
    return no_alias
848903
public void removeTypeParam(String key) {

        List<String> selectedTypes = m_searchObject.getTypes();
        if (selectedTypes.contains(key)) {
            m_handler.onClearTypes(Collections.singletonList(key));
            selectedTypes.remove(key);
            updateResultsTab(false);
            ValueChangeEvent.fire(this, m_searchObject);
        }
    }
1344176
@SuppressWarnings("unchecked")
    private void removeFormerFacets(UIComponent component)
    {
        List<String> formerFacetNames = (List<String>)component.getAttributes().get(FORMER_FACET_NAMES_SET_ATTR);
        if (formerFacetNames != null)
        {
            for (String facetName : formerFacetNames)
            {
                if (_facetsAdded == null || !_facetsAdded.contains(facetName))
                {
                    component.getFacets().remove(facetName);
                }
            }
            if (_facetsAdded == null)
            {
                component.getAttributes().remove(FORMER_FACET_NAMES_SET_ATTR);
            }
            else
            {
                component.getAttributes().put(FORMER_FACET_NAMES_SET_ATTR, _facetsAdded);
            }
        }
        else
        {
            if (_facetsAdded != null)
            {
                component.getAttributes().put(FORMER_FACET_NAMES_SET_ATTR, _facetsAdded);
            }
        }
    }
915233
public function removeType(string $type)
    {
        if (!$this->removing && Type::hasType($type)) {
            $this->removing = true;
            Type::overrideType($type, null);
        }

        $this->removing = false;
        unset($this->types[$type]);
    }
118793
public ConverterRegistry putCustom(Type type, Converter<?> converter) {
		if (null == customConverterMap) {
			synchronized (this) {
				if (null == customConverterMap) {
					customConverterMap = new ConcurrentHashMap<>();
				}
			}
		}
		customConverterMap.put(type, converter);
		return this;
	}
1087879
public PartialConverter removePartialConverter(PartialConverter converter)
            throws SecurityException {
        
        checkAlterPartialConverters();
        if (converter == null) {
            return null;
        }
        PartialConverter[] removed = new PartialConverter[1];
        iPartialConverters = iPartialConverters.remove(converter, removed);
        return removed[0];
    }
796139
protected <T> void addConverter(Class<T> type, Converter<T> converter) {
        storage.put(type, converter);
    }
1265892
public boolean removeOfType(final Class<? extends Tag> type) {
	write.lock();
	try {
	    return tags.remove(type) != null;
	} finally {
	    write.unlock();
	}
    }
895423
public IntervalConverter removeIntervalConverter(IntervalConverter converter)
            throws SecurityException {
        
        checkAlterIntervalConverters();
        if (converter == null) {
            return null;
        }
        IntervalConverter[] removed = new IntervalConverter[1];
        iIntervalConverters = iIntervalConverters.remove(converter, removed);
        return removed[0];
    }