Returns list of all removed values

@see IAdditionalDescriptors#removeAttribute(java.lang.String)
182615
@Override
    public List<Object> removeAttribute(final String name) {
        List<Object> removedValues = null;

        for (final IAdditionalDescriptors additionalDescriptors : this.delegateDescriptors) {
            final List<Object> values = additionalDescriptors.removeAttribute(name);
            if (values != null) {
                if (removedValues == null) {
                    removedValues = new ArrayList<>(values);
                } else {
                    removedValues.addAll(values);
                }
            }
        }

        return removedValues;
    }
392553
function removeAttribute(element, name) {
    element = getComponentNode(element) || element;
    let oldValue = element.getAttribute(name);
    element.removeAttribute(name);
    return update(element, name, oldValue, null);
}
139358
public void removeAttribute(String arg0) {
        // 321485
        if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"removeAttribute", "this->"+this+": "+" name --> " + arg0);
        }
        if (WCCustomProperties.CHECK_REQUEST_OBJECT_IN_USE){
            checkRequestObjectInUse();
        }
        Object oldValue = _srtRequestHelper._attributes.remove(arg0);
        if (oldValue != null) {
            this.attributeRemoved(arg0, oldValue);
        }
    }
665400
public AttributeDataset remove(String... cols) {
        HashSet<String> remains = new HashSet<>();
        for (Attribute attr : attributes) {
            remains.add(attr.getName());
        }
        for (String col : cols) {
            remains.remove(col);
        }

        Attribute[] attrs = new Attribute[remains.size()];
        int[] index = new int[remains.size()];
        for (int j = 0, i = 0; j < attributes.length; j++) {
            if (remains.contains(attributes[j].getName())) {
                index[i] = j;
                attrs[i] = attributes[j];
                i++;
            }
        }

        AttributeDataset sub = new AttributeDataset(name, attrs, response);
        for (Datum<double[]> datum : data) {
            double[] x = new double[index.length];
            for (int i = 0; i < x.length; i++) {
                x[i] = datum.x[index[i]];
            }
            Row row = response == null ? sub.add(x) : sub.add(x, datum.y);
            row.name = datum.name;
            row.weight = datum.weight;
            row.description = datum.description;
            row.timestamp = datum.timestamp;
        }

        return sub;
    }
942215
public String delete_attribute(Map<String, Object> data) {
        String type = data.get("type").toString();
        Gson gson = new Gson();
        String json = gson.toJson(data);
        return post("attribute/" + type, json);
    }
1161565
private List<Attribute> removeEmptyAndOverrideAttrs(List<Attribute> attrs) {
        if (attrs == null)
            return null;
        List<Attribute> toKeep = new ArrayList<Attribute>();
        for (Attribute attr : attrs) {
            if (attr.getAttributeName() != null && attr.getAttributeName().trim().length() > 0 &&
                    attr.getAttributeValue() != null && attr.getAttributeValue().trim().length() > 0 &&
                    !WorkAttributeConstant.isOverrideAttribute(attr.getAttributeName()) &&
                    !attr.getAttributeName().equals("REFERENCED_ACTIVITIES") &&
                    !attr.getAttributeName().equals("REFERENCED_PROCESSES")) {
                toKeep.add(attr);
            }
        }
        return toKeep;
    }
926163
def removeDefaultAttributeValue(node, attribute):
    
    if not node.hasAttribute(attribute.name):
        return 0

    # differentiate between text and numeric values
    if isinstance(attribute.value, str):
        if node.getAttribute(attribute.name) == attribute.value:
            if (attribute.conditions is None) or attribute.conditions(node):
                node.removeAttribute(attribute.name)
                return 1
    else:
        nodeValue = SVGLength(node.getAttribute(attribute.name))
        if ((attribute.value is None)
                or ((nodeValue.value == attribute.value) and not (nodeValue.units == Unit.INVALID))):
            if ((attribute.units is None)
                    or (nodeValue.units == attribute.units)
                    or (isinstance(attribute.units, list) and nodeValue.units in attribute.units)):
                if (attribute.conditions is None) or attribute.conditions(node):
                    node.removeAttribute(attribute.name)
                    return 1

    return 0
1300113
@Override
    public void removeAttribute(String name) {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isDebugEnabled()) {
            Tr.debug(tc, "removeAttribute: " + name);
        }
        if (isInvalid()) {
            throw new IllegalStateException("Session is invalid");
        }
        Object attr = this.attributes.remove(name);
        if (null == attr) {
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Attribute not found");
            }
            return;
        }
        HttpSessionBindingEvent event = null;
        if (attr instanceof HttpSessionBindingListener) {
            // this value wants to know when it's removed
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Notifying value; " + attr);
            }
            event = new HttpSessionBindingEvent(this, name, attr);
            ((HttpSessionBindingListener) attr).valueUnbound(event);
        }
        // List<HttpSessionAttributeListener> listeners = this.myConfig.getSessionAttributeListeners();
        // if (null != listeners) {
        // // notify any session-attribute listeners that were registered
        // // in the module configuration
        // if (null == event) {
        // event = new HttpSessionBindingEvent(this, name, attr);
        // }
        // for (HttpSessionAttributeListener listener : listeners) {
        // if (bTrace && tc.isDebugEnabled()) {
        // Tr.debug(tc, "Notifying listener: " + listener);
        // }
        // listener.attributeRemoved(event);
        // }
        // }
    }
393982
def clear_attributes(self):
        
        self._attrs = {} # removes all attr
        for name, attr_field in six.iteritems(self._ftype.attrs):
            self._attrs[name] = []
94112
function removeAttrsValues(attrs, ignoreAttributes) {
    _.forEach(ignoreAttributes, function (attr) {
        var attrIndexes = _getIndexesInArray(attrs, attr);

        _.forEach(attrIndexes, function (index) {
            attrs[index].value = '';
        });
    });

    return attrs;
}
1348689
public function removeAttribute() {
    $args = func_get_args();
    foreach ($args as $arg) {
      // Support arrays or multiple arguments.
      if (is_array($arg)) {
        foreach ($arg as $value) {
          unset($this->storage[$value]);
        }
      }
      else {
        unset($this->storage[$arg]);
      }
    }

    return $this;
  }
976027
def remove_on_change(self, attr, *callbacks):
        '''  '''
        if len(callbacks) == 0:
            raise ValueError("remove_on_change takes an attribute name and one or more callbacks, got only one parameter")
        _callbacks = self._callbacks.setdefault(attr, [])
        for callback in callbacks:
            _callbacks.remove(callback)
135399
public Attribute removeAttribute(String name)
  {
    for (int i = _attributes.size() - 1; i >= 0; i--) {
      Attribute attr = _attributes.get(i);

      if (attr.getName().equals(name)) {
        _attributes.remove(i);
        return attr;
      }
    }

    return null;
  }
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;
    }
767712
public void removeUncacheableAttributes(Map<String, Object> attributeMap) {

        for (String uncacheableAttribute : uncacheableAttributes) {
            attributeMap.remove(uncacheableAttribute);
        }
        attributeMap.remove(CmsFlexController.ATTRIBUTE_NAME);
        attributeMap.remove(CmsDetailPageResourceHandler.ATTR_DETAIL_CONTENT_RESOURCE);
        attributeMap.remove(CmsDetailPageResourceHandler.ATTR_DETAIL_FUNCTION_PAGE);
    }
74533
public void removeAttribute(String attributeName) {
        synchronized (_iSession) {
            if (!_iSession.isValid())
                throw new IllegalStateException();
            Object object = _iSession.removeAttribute(attributeName);
        }
    }
600900
private final void removePointsFromAttr(final Element element,
            final String attr) {
        final String value; // Content of the attribute

        // Takes and clean the old attribute value
        value = element.attr(attr).replaceAll("\\.", "");

        // Sets the cleaned value
        element.attr(attr, value);
    }