Removes the field with the given name from the given ObjectNode
547266
public static JsonNode remove(ObjectNode obj, String fieldName) {
		JsonNode result = null;
		if (obj != null) {
			result = obj.remove(fieldName);
		}
		return result;
	}
184644
def delete_object(self, object_name):
        
        self._client.remove_object(self._instance, self.name, object_name)
210478
Object forceRemoveField(String name)
    {
        int saved_state = _state;
        try
        {
            _state = __MSG_EDITABLE;
            return removeField(name);
        }
        finally
        {
            _state = saved_state;
        }
    }
1179189
def remove_object(self, name):
        
        if name not in self._object_map:
            raise RuntimeError('No object with name {} is registered.'.format(name))

        for fn_name in list(self._function_map.keys()):
            if fn_name.startswith(name + '.') or fn_name.startswith(name + ':'):
                self._remove_function(fn_name)

        del self._object_map[name]
597794
private void removeFromIndices(T object) {
    for (FieldIndex<T, ?> fieldValue : mIndices.values()) {
      fieldValue.remove(object);
    }
  }
1278693
function removePropValue(node, name) {
    var propInfo = properties.hasOwnProperty(name) && properties[name];
    if (propInfo) {
        if (propInfo.mustUseProperty) {
            var propName = propInfo.propertyName;
            if (propInfo.hasBooleanValue) {
                node[propName] = false;
            } else {
                node[propName] = '';
            }
        } else {
            node.removeAttribute(propInfo.attributeName);
        }
    } else if (isCustomAttribute(name)) {
        node.removeAttribute(name);
    }
}
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));
			}
		});
	}
1265552
@Override
    public void delete(ZooPC obj) {
    	if (obj.getClass() == GenericObject.class) {
    		throw new IllegalArgumentException();
//    		deleteGeneric((GenericObject) obj);
//    		return;
    	}
    	
        if (!isStarted) {
            this.sie = node.getSchemaIE(cls);
            isStarted = true;
        }

        //updated index
        //This is buffered to reduce look-ups to find field indices.
        buffer[bufferCnt++] = obj;
        if (bufferCnt == BUFFER_SIZE) {
            flushBuffer();
        }
    }
270013
void removeMembership(Node refUserNode, Node refTypeNode) throws Exception
   {
      refTypeNode.remove();
      if (!refUserNode.hasNodes())
      {
         refUserNode.remove();
      }
   }
411596
public static synchronized void removeConfig(String objectId) {
        String uri = uriMap.get(objectId);
        if (uri != null) {
            configInfo.remove(uri);
        }
        uriMap.remove(objectId);
        resolvedConfigInfo.clear();
    }
802073
function clearField(index, properties) {
        // Aliased fields reflect values on other fields and do not need to be cleared.
        if (properties.isAlias === true) {
            return;
        }

        // In case of object & array, they must be initialized immediately.
        if (properties.type === 'object') {
            this[properties.name].clear();

            // Native arrays are never used so that toArray can be globally supported.
            // Additionally, other properties such as unique rely on passing through SchemaObject.
        } else if (properties.type === 'array') {
            this[properties.name].length = 0;

            // Other field types can simply have their value set to undefined.
        } else {
            writeValue.call(this[_privateKey]._this, undefined, properties);
        }
    }
144135
function remove(oTarget, oListener, oConfiguration) {
		oConfiguration = oConfiguration || getConfiguration(oTarget, oListener);
		updateConfiguration(oTarget, oListener, oConfiguration, true);
	}
1308414
@Nullable V removeNoWriter(Object key) {
    Node<K, V> node = data.remove(nodeFactory.newLookupKey(key));
    if (node == null) {
      return null;
    }

    V oldValue;
    synchronized (node) {
      oldValue = node.getValue();
      if (node.isAlive()) {
        node.retire();
      }
    }

    RemovalCause cause;
    if (oldValue == null) {
      cause = RemovalCause.COLLECTED;
    } else if (hasExpired(node, expirationTicker().read())) {
      cause = RemovalCause.EXPIRED;
    } else {
      cause = RemovalCause.EXPLICIT;
    }

    if (hasRemovalListener()) {
      @SuppressWarnings("unchecked")
      K castKey = (K) key;
      notifyRemoval(castKey, oldValue, cause);
    }
    afterWrite(new RemovalTask(node));
    return (cause == RemovalCause.EXPLICIT) ? oldValue : null;
  }
467762
private void parseFieldRemove(String fieldName, UNode addNode) {
        Set<String> removeValueSet = new LinkedHashSet<>();
        for (UNode valueNode : addNode.getMemberList()) {
            Utils.require(valueNode.isValue() && valueNode.getName().equals("value"),
                          "Value expected for 'remove' element: " + valueNode);
            removeValueSet.add(valueNode.getValue());
        }
        removeFieldValues(fieldName, removeValueSet);
    }
999688
def remove_field(self, path, name):
        
        path = make_path(path)
        container = self.get_container(path)
        try:
            value = container._values[name]
            if isinstance(value, ValueTree):
                raise TypeError()
            del container._values[name]
        except KeyError:
            pass
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
745989
public int removeChildObjectsByName(final String name) {
        int removed = 0;

        if (null != name && !name.isEmpty()) {
            removed = removeChildObjectsByNameImpl(name);
        }

        return removed;
    }