<p>remove a specified data-* attribute.</p>

@param key data-"key"
@return the previous value associated with key, or null if there was no mapping for key.
425402
public String removeData(String key) {
        QName qn = new QName("data-" + key);
        return this.getOtherAttributes().remove(qn);
    }
724627
public Object remove(Object key)
    {
        synchronized (objects)
        {
            Object remove = objects.remove(key);
            objectTimeStamps.remove(key);
            if (remove != null)
            {
                findNextExpireTime();
            }
            return remove;
        }
    }
440521
@Override
    public String remove(Object key) {

        String result = m_configurationStrings.remove(key);
        m_configurationObjects.remove(key);
        return result;
    }
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
928473
private static String stripKey(final String key) {
        int index = key.indexOf(".");
        if (index > 0) {
            return key.substring(0, index);
        }
        return null;
    }
1344687
public Object attribute(Object key) {
        return (attributes != null) ? attributes.get(key) : null;
    }
1156986
@Nullable
  public synchronized V remove(K key) {
      V oldValue = mMap.remove(key);
      mSizeInBytes -= getValueSizeInBytes(oldValue);
      return oldValue;
  }
412691
public V remove(final int key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        Object value;
        while (null != (value = values[index]))
        {
            if (key == keys[index])
            {
                values[index] = null;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return unmapNullValue(value);
    }
1342594
@Override
  public V remove(Object key)
  {
    if (key == null) {
      V value = _nullValue;
      _nullValue = null;
      return value;
    }

    int hash = key.hashCode() & _mask;
    int count = _size + 1;

    V item = null;

    for (; count > 0; count--) {
      item = _values[hash];

      if (item == null)
        return null;

      if (_keys[hash].equals(key)) {
        _keys[hash] = null;
        _values[hash] = null;
        _size--;

        refillEntries(hash);
        break;
      }

      hash = (hash + 1) & _mask;
    }

    if (count < 0)
      throw new RuntimeException("internal cache error");

    return item;
  }
23113
public Object remove(Object key)
    {
        if (key == null) return null;
        purge();
        int hash = hashCode(key);
        int index = indexFor(hash);
        Entry previous = null;
        Entry entry = table[index];
        while (entry != null)
        {
            if ((hash == entry.hash) && equals(key, entry.getKey()))
            {
                if (previous == null)
                    table[index] = entry.next;
                else
                    previous.next = entry.next;
                this.size--;
                modCount++;
                return entry.getValue();
            }
            previous = entry;
            entry = entry.next;
        }
        return null;
    }
253670
public T remove(final int key) {

        final int hash  = hashOf(key);
        int index = hash & mask;
        if (containsKey(key, index)) {
            return doRemove(index);
        }

        if (states[index] == FREE) {
            return missingEntries;
        }

        int j = index;
        for (int perturb = perturb(hash); states[index] != FREE; perturb >>= PERTURB_SHIFT) {
            j = probe(perturb, j);
            index = j & mask;
            if (containsKey(key, index)) {
                return doRemove(index);
            }
        }

        return missingEntries;

    }
359110
public V remove (Object key)
    {
        V removed = _delegate.remove(key);
        entryRemoved(removed);
        return removed;
    }
302216
public synchronized XAttribute remove(Object key) {
		try {
			XAttributeMap map = deserialize();
			XAttribute retVal = map.remove(key);
			serialize(map);
			return retVal;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}
1359465
public Object remove (int key)
    {
        int size = _keys.length, start = key % size;
        for (int ii = 0; ii < size; ii++) {
            int idx = (ii + start) % size;
            if (_keys[idx] == key) {
                Object value = _values[idx];
                _keys[idx] = -1;
                _values[idx] = null;
                return value;
            }
        }
        return null;
    }
846371
public void remove(String key) {
        String processedKey = processKey(key);
        String orderKey = null;

        // removing key set for all positions
        for (int i = 0; i < this.order.size(); i++) {
            orderKey = this.order.get(i);

            if (orderKey != null && orderKey.equals(processedKey) == true) {
                this.order.remove(i);
            }
        }

        this.types.remove(processedKey);
        this.direction.remove(processedKey);
        this.values.remove(processedKey);
    }
341347
public void removeNodeMetaData(Object key) {
        if (key==null) throw new GroovyBugError("Tried to remove meta data with null key "+this+".");
        if (metaDataMap == null) {
            return;
        }
        metaDataMap.remove(key);
    }
381370
@Override
    public Object removeEL(Key key) {
	try {
	    return remove(key);
	}
	catch (PageException e) {
	    return null;
	}
    }