Removes a value to the list.

@param associationValue The value to be removed from the list.
@return Returns true in case of successful removal.
326121
public boolean deleteValue(AssociationValue associationValue) {
		if (idByValue.containsKey(associationValue)) {
			for (ListGridRecord record : getRecords()) {
				if (record.getAttributeAsObject(VALUE_HOLDER_RECORD_ATTRIBUTE) == associationValue) {
					removeData(record);
					idByValue.remove(associationValue);
					return true;
				}
			}
		}
		return false;
	}
967768
public final void removeValue(@NonNull final String value) {
        Condition.INSTANCE.ensureNotNull(value, "The value may not be null");

        if (this.values != null) {
            if (this.values.remove(value)) {
                if (persistSet(this.values)) {
                    notifyChanged();
                }
            }
        }
    }
334690
async function _removeAssociation(
  ownerModel,
  ownerObject,
  childModel,
  childId,
  associationName,
  Log
) {
  let childObject = await childModel.findOne({ _id: childId })
  if (childObject) {
    let association = ownerModel.routeOptions.associations[associationName]
    let associationType = association.type
    if (associationType === 'ONE_MANY') {
      // EXPL: one-many associations are virtual, so only update the child reference
      // childObject[association.foreignField] = null; //TODO: set reference to null instead of deleting it?
      // EXPL: only delete the reference if the ids match
      if (
        childObject[association.foreignField] &&
        childObject[association.foreignField].toString() ===
          ownerObject._id.toString()
      ) {
        childObject[association.foreignField] = undefined
      }
      await childObject.save()
    } else if (associationType === 'MANY_MANY') {
      // EXPL: remove references from both models

      // EXPL: if linking models aren't embeded, just upsert the linking model collection
      let embedAssociation =
        association.embedAssociation === undefined
          ? config.embedAssociations
          : association.embedAssociation
      if (!embedAssociation) {
        const linkingModel = association.include.through
        let query = {}
        query[ownerModel.modelName] = ownerObject._id
        query[childModel.modelName] = childObject._id

        await linkingModel.findOneAndRemove(query)
      } else {
        // EXPL: remove the associated child from the owner
        let deleteChild = ownerObject[associationName].filter(child => {
          return (
            child[childModel.modelName].toString() ===
            childObject._id.toString()
          )
        })
        deleteChild = deleteChild[0]

        let index = ownerObject[associationName].indexOf(deleteChild)
        if (index > -1) {
          ownerObject[associationName].splice(index, 1)
        }

        // EXPL: get the child association name
        let childAssociation = {}
        let childAssociations = childModel.routeOptions.associations
        for (let childAssociationKey in childAssociations) {
          let association = childAssociations[childAssociationKey]
          if (association.model === ownerModel.modelName) {
            childAssociation = association
          }
        }
        let childAssociationName = childAssociation.include.as

        // EXPL: remove the associated owner from the child
        let deleteOwner = childObject[childAssociationName].filter(owner => {
          return (
            owner[ownerModel.modelName].toString() ===
            ownerObject._id.toString()
          )
        })
        deleteOwner = deleteOwner[0]

        index = childObject[childAssociationName].indexOf(deleteOwner)
        if (index > -1) {
          childObject[childAssociationName].splice(index, 1)
        }

        await Promise.all([
          ownerModel.findByIdAndUpdate(ownerObject._id, ownerObject, {
            runValidators: config.enableMongooseRunValidators
          }),
          childModel.findByIdAndUpdate(childObject._id, childObject, {
            runValidators: config.enableMongooseRunValidators
          })
        ])
      }
    } else if (associationType === '_MANY') {
      // EXPL: remove reference from owner model

      // EXPL: remove the associated child from the owner
      let deleteChild = ownerObject[associationName].filter(childId => {
        return childId.toString() === childObject._id.toString()
      })
      deleteChild = deleteChild[0]

      let index = ownerObject[associationName].indexOf(deleteChild)
      if (index > -1) {
        ownerObject[associationName].splice(index, 1)
      }

      await Promise.all([
        ownerModel.findByIdAndUpdate(ownerObject._id, ownerObject, {
          runValidators: config.enableMongooseRunValidators
        })
      ])
    } else {
      throw Boom.badRequest('Association type incorrectly defined.')
    }
  } else {
    throw Boom.notFound('Child object not found.')
  }
}
1260285
public E removeBy(String attributeName, String attributeValue) {
        // traverses the list twice, but reuse code
        E element = this.getBy(attributeName, attributeValue);
        if (element != null) {
            this.remove(element); // this should always return true since we already found the element
        }
        return element;
    }
943645
public boolean remove(String inputKey, String inputValue) {
        String key = Normalizer.normalize(inputKey, Normalizer.NORMALIZE_LOWER);
        String value = Normalizer.normalize(inputValue, Normalizer.NORMALIZE_LOWER);
        boolean rc = remove(this.values.get(key), value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "remove: " + key + "=" + value + " rc=" + rc);
        }
        return rc;
    }
241196
public boolean clearValue(String name) {
        String cleanName = cleanupValue(name);
        boolean result = getCurrentValues().containsKey(cleanName);
        getCurrentValues().remove(cleanName);
        return result;
    }
361341
public void removeValue() {

        if (!isSimpleValue()) {
            m_hasValue = false;
            m_widgetHolder.clear();
            generateLabel();
        } else {
            // only deactivate the widget and restore the default value
            m_widget.setActive(false);
            m_widget.setValue("");
            addActivationHandler();
        }
        addStyleName(formCss().emptyValue());
        removeValidationMessage();
    }
400005
public boolean removeValue(String name, V value) {
        List<V> lo = get(name);
        if ((lo == null) || (lo.isEmpty())) {
            return false;
        }
        boolean ret = lo.remove(value);
        if (lo.isEmpty()) {
            remove(name);
        } else {
            put(name, lo);
        }
        return ret;
    }
306512
public boolean remove(final long value) {
        int index = longHash(value, mask);

        while (values[index] != missingValue) {
            if (values[index] == value) {
                values[index] = missingValue;
                compactChain(index);
                size--;
                return true;
            }

            index = next(index);
        }

        return false;
    }
667988
public void addOneToManyValue(String name, AssociationValue value) {
		Attribute attribute = getAttributes().get(name);
		if (!(attribute instanceof OneToManyAttribute)) {
			throw new IllegalStateException("Cannot set oneToMany value on attribute with different type, " +
					attribute.getClass().getName() + " setting value " + value);
		}
		OneToManyAttribute oneToMany = (OneToManyAttribute) attribute;
		if (oneToMany.getValue() == null) {
			oneToMany.setValue(new ArrayList<AssociationValue>());
		}
		oneToMany.getValue().add(value);
	}
1291275
public void removeValue(T value, boolean reload) {
        int idx = getIndex(value);
        if (idx >= 0) {
            removeItemInternal(idx, reload);
        }
    }
384281
private boolean updateLinkRemoveValues() {
        Set<String> removeSet = m_dbObj.getRemoveValues(m_fieldName);
        List<String> addSet = m_dbObj.getFieldValues(m_fieldName);
        if (removeSet != null && addSet != null) {
            removeSet.removeAll(addSet);    // add+remove of same ID negates the remove
        }
        if (removeSet == null || removeSet.size() == 0) {
            return false;
        }
        
        for (String removeObjID : removeSet) {
            deleteLinkValue(removeObjID);
        }
        return true;
    }
275730
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        accessorDict = self._accessorDict(memberName, classNamingConvention)
        for accessorName, _ in accessorDict.items():
            if accessorName not in originalMemberNameList and hasattr(cls, accessorName):
                delattr(cls, accessorName)
13569
def txn_removeAssociation(self, server_url, handle):
        
        self.db_remove_assoc(server_url, handle)
        return self.cur.rowcount > 0
943922
public boolean removeAll(final IntHashSet coll)
    {
        boolean acc = false;

        for (final int value : coll.values)
        {
            if (value != MISSING_VALUE)
            {
                acc |= remove(value);
            }
        }

        if (coll.containsMissingValue)
        {
            acc |= remove(MISSING_VALUE);
        }

        return acc;
    }
293435
public boolean deleteByIds(Object... idValues) {
		Table table = _getTable();
		if (idValues == null || idValues.length != table.getPrimaryKey().length)
			throw new IllegalArgumentException("Primary key nubmer must equals id value number and can not be null");
		
		return deleteById(table, idValues);
	}
737490
public int deleteValue(String property, String value) {
		int count = 0;
		if (has()) {
			Map<String, Object> fieldValues = buildFieldValues(property, value);
			count = getDao().delete(fieldValues);
		}
		return count;
	}