Remove introspected value
@param m The map
@param name The name
439998
private static void removeIntrospectedValue(Map<String, String> m, String name)
   {
      if (m != null)
      {
         m.remove(name);

         if (name.length() == 1)
         {
            name = name.toUpperCase(Locale.US);
         }
         else
         {
            name = name.substring(0, 1).toUpperCase(Locale.US) + name.substring(1);
         }

         m.remove(name);

         if (name.length() == 1)
         {
            name = name.toLowerCase(Locale.US);
         }
         else
         {
            name = name.substring(0, 1).toLowerCase(Locale.US) + name.substring(1);
         }

         m.remove(name);
      }
   }
1149438
public void removeVariable(String name)
    {
        Map<String, Iterable<? extends WindupVertexFrame>> frame = peek();
        frame.remove(name);
    }
820194
private static final void auditNamedValues(String m, Map<String, ?> namedValues) {
        if (logger.isDebugEnabled()) {
            assert namedValues != null;
            for (Iterator<String> outer = namedValues.keySet().iterator(); outer
                    .hasNext();) {
                Object name = outer.next();
                assert name instanceof String : "not a string, name==" + name;
                StringBuffer sb = new StringBuffer(m + name + "==");
                Object temp = namedValues.get(name);
                assert temp instanceof String || temp instanceof Set : "neither string nor set, temp=="
                        + temp;
                if (temp instanceof String) {
                    sb.append(temp.toString());
                } else if (temp instanceof Set) {
                    @SuppressWarnings("unchecked")
                    Set<String> values = (Set<String>) temp;
                    sb.append("(" + values.size() + ") {");
                    String punct = "";
                    for (Iterator<String> it = values.iterator(); it.hasNext();) {
                        String value = it.next();
                        sb.append(punct + value);
                        punct = ",";
                    }
                    sb.append("}");
                }
                logger.debug(sb.toString());
            }
        }
    }
49661
public void removeParameter(String name) {
		if(name == null) {
			throw new NullPointerException("parameter name is null ! ");
		}
		if(isModifiable == ModifiableRule.NotModifiable) {
			throw new IllegalStateException("it is forbidden to modify the parameters");
		}
		if(name.equalsIgnoreCase("tag") && (isModifiable == ModifiableRule.From || isModifiable == ModifiableRule.To)) {
			throw new IllegalStateException("it is forbidden to remove the tag parameter on To or From Header");
		}
		if(name.equalsIgnoreCase("branch") && isModifiable == ModifiableRule.Via) {
			throw new IllegalStateException("it is forbidden to set the branch parameter on the Via Header");
		}
		this.parameters.remove(name);
		if(header != null) {
			header.removeParameter(name);
		}
	}
848620
public static void removeSyncCache(String name) {
		if (StrKit.isBlank(name)) {
			return;
		}
		if (GlobalSyncRedis.caches.containsKey(name)) {
			GlobalSyncRedis.caches.remove(name);
		}
	}
744819
public void removeFile(String name) {
        if(files.containsKey(name)) {
            files.remove(name);
        }

        if(fileStreams.containsKey(name)) {
            fileStreams.remove(name);
        }
    }
417758
public String remove(String name)
    {
        String old=null;
        FieldInfo info=getFieldInfo(name);
        Field field=getField(info,true);

        if (field!=null)
        {
            old=field._value;
            while(field!=null)
            {
                field.clear();
                field=field._next;
            }
        }
        
        return old;
    }
241196
public boolean clearValue(String name) {
        String cleanName = cleanupValue(name);
        boolean result = getCurrentValues().containsKey(cleanName);
        getCurrentValues().remove(cleanName);
        return result;
    }
822460
@Override
    public void remove(String name)
            throws IOException, IllegalArgumentException {
        
        checkWritable();
        
        final FatLfnDirectoryEntry entry = getEntry(name);
        if (entry == null) return;
        
        unlinkEntry(entry);
        
        final ClusterChain cc = new ClusterChain(
                fat, entry.realEntry.getStartCluster(), false);

        cc.setChainLength(0);
        
        updateLFN();
    }
329549
@Override
	public void removeField(final String name) {

		template.execute(solrClient -> {

			try {
				UpdateResponse response = new SchemaRequest.DeleteField(name).process(solrClient, collection);
				if (hasErrors(response)) {
					throw new SchemaModificationException(
							String.format("Removing field with name %s from collection %s failed with status %s. Server returned %s.",
									name, collection, response.getStatus(), response));
				}

				return Integer.valueOf(response.getStatus());
			} catch (Exception e) {
				throw new SchemaModificationException(
						String.format("Removing field with name %s from collection %s failed.", name, collection));
			}
		});
	}
836940
public App removeSetting(String name) {
		if (!StringUtils.isBlank(name)) {
			Object result = getSettings().remove(name);
			if (result != null) {
				for (AppSettingRemovedListener listener : REMOVE_SETTING_LISTENERS) {
					listener.onSettingRemoved(this, name);
					logger.debug("Executed {}.onSettingRemoved().", listener.getClass().getName());
				}
			}
		}
		return this;
	}
654903
public JsonObject removeKey(String name) {
        content.remove(name);
        if (this.encryptionPathInfo != null && this.encryptionPathInfo.entrySet().contains(name)) {
            this.encryptionPathInfo.remove(name);
        }
        return this;
    }
266910
public void removeTieable(String name){
        T t = tieables.remove(name);
        if (t==null)
            return;
        detachFromListener(t);
        try{
            //in case its yet untied.
            yetUntied.remove(t);
        }catch(Exception e){/* ignored */}

    }
678735
public void remove(K key) {

        V removedValue = m_forwardMap.remove(key);
        if (removedValue != null) {
            m_reverseMap.remove(removedValue, key);
        }
    }
913820
public void removeToken(String name) {
        if (name == null || name.isEmpty()) {
            return;
        }

        for (Iterator<AntiCsrfParamToken> it = tokens.iterator(); it.hasNext();) {
            AntiCsrfParamToken token = it.next();
            if (name.equals(token.getName())) {
                it.remove();
                if (token.isEnabled()) {
                    this.enabledTokensNames.remove(name);
                }
                break;
            }
        }
    }
1246609
public void clearValues(String fieldName) {
        Utils.require(!Utils.isEmpty(fieldName), "fieldName");
        m_valueMap.remove(fieldName);
        m_valueRemoveMap.remove(fieldName);
    }
138759
@Override
    public void removeMonomer(String name) {
        if (monomers.containsKey(name)) {
            Monomer monomer = (Monomer) monomers.get(name);
            this.remove(monomer);
            monomers.remove(name);
        }
    }