removes a page from the page pool

@param key key reference to page object
@return page object matching to key reference
347969
public boolean remove(String key) {

	if (pageSources.remove(key.toLowerCase()) != null) return true;

	Set<String> set = pageSources.keySet();
	String[] keys = set.toArray(new String[set.size()]); // done this way to avoid ConcurrentModificationException
	PageSource ps;
	for (String k: keys) {
	    ps = pageSources.get(k);
	    if (key.equalsIgnoreCase(ps.getClassName())) {
		pageSources.remove(k);
		return true;
	    }
	}
	return false;
    }
430059
public Map<String, String> removeRequestHeader(String key) {
    this.requestHeaders.remove(key);
    return getRequestHeaders();
  }
663127
@Override
    public V remove(Object key) {
        final V old = this.get(key);
        this.cache.remove((Serializable) key);
        return old;
    }
1277044
public static final void remove(String key) {
        Map<String, Object> ctx = CTX_HOLDER.get();
        if (ctx != null) {
            ctx.remove(key);
        }
    }
1098424
public Object remove(Serializable key) {
        if(component.initialStateMarked()) {
            Object retVal = deltaMap.remove(key);

            if(retVal==null) {
                return defaultMap.remove(key);
            }
            else {
                defaultMap.remove(key);
                return retVal;
            }
        }
        else {
            return defaultMap.remove(key);
        }
    }
704557
public MapUpdate removeSet(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.SET, k));
        return this;
    }
1097831
public Controller removeSessionAttr(String key) {
		HttpSession session = request.getSession(false);
		if (session != null)
			session.removeAttribute(key);
		return this;
	}
131324
@Override
    public V remove(@NonNull K key) {
        V removed = super.remove(key);
        mHashMap.remove(key);
        return removed;
    }
1265857
public V remove(K key) {
        final int hash = key.hashCode();
        final int row = hash / SIZE_ROW;
        final int column = hash & (SIZE_ROW - 1); // DON'T use the % operator as we
                                                  // need the result to be
                                                  // non-negative (-1%16 is -1 for
                                                  // example)
        final V rc = get(row, column);
        validateKey(hash);
        validateTable(row);
        this.values[row][column] = null;
        this.keys[hash] = null;
        return rc;
    }
1034536
protected LinkedElement<T> removeElem(final T key) {
    LinkedElement<T> found = null;
    final int hashCode = key.hashCode();
    final int index = getIndex(hashCode);
    if (entries[index] == null) {
      return null;
    } else if (hashCode == entries[index].hashCode &&
            entries[index].element.equals(key)) {
      // remove the head of the bucket linked list
      modification++;
      size--;
      found = entries[index];
      entries[index] = found.next;
    } else {
      // head != null and key is not equal to head
      // search the element
      LinkedElement<T> prev = entries[index];
      for (found = prev.next; found != null;) {
        if (hashCode == found.hashCode &&
                found.element.equals(key)) {
          // found the element, remove it
          modification++;
          size--;
          prev.next = found.next;
          found.next = null;
          break;
        } else {
          prev = found;
          found = found.next;
        }
      }
    }
    return found;
  }
857301
public boolean remove(K key) {
        if (null == key)
            return false;
        CacheReference<K> keyRef = lookupFactory.createKey(key, queue);
        return CacheKey.class.cast(keyRef).removeCacheEntry();
    }
247518
public Result<T> remove(ServiceInfo.Key key)
    {
        T previous = null;

        lock();
        try
        {
            ServiceType serviceType = keysToServiceTypes.remove(key);
            if (serviceType == null) return new Result<T>(null, null);
            previous = keysToServiceInfos.remove(key);
            previous.setRegistered(false);
        }
        finally
        {
            unlock();
        }

        notifyServiceRemoved(previous, null);
        return new Result<T>(previous, null);
    }
599593
@Override
    public V remove(Object key) {
        int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }
410640
public static Single<Long> removes(String key, Set members) {
        return removes(CacheService.CACHE_CONFIG_BEAN, key, members);
    }
793557
public String remove(String group, Object key) {
		return this.groupedMap.remove(group, Convert.toStr(key));
	}
487322
public static Single<Long> remove(String key, Object member) {
        return remove(CacheService.CACHE_CONFIG_BEAN, key, member);
    }
1314573
public MapUpdate removeMap(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.MAP, k));
        return this;
    }