Removes evidence from the collection.

@param type the type of evidence (vendor, product, version)
@param e Evidence.
177111
public synchronized void removeEvidence(EvidenceType type, Evidence e) {
        if (null != type) {
            switch (type) {
                case VENDOR:
                    vendors.remove(e);
                    break;
                case PRODUCT:
                    products.remove(e);
                    break;
                case VERSION:
                    versions.remove(e);
                    break;
                default:
                    break;
            }
        }
    }
884888
@Override
    public void remove(TypeCategory typeCategory, String typeName)
            throws AtlasException {

        assertValidTypeCategory(typeCategory);
        remove(typeName);
    }
1191537
public synchronized Set<Evidence> getEvidence(EvidenceType type) {
        if (null != type) {
            switch (type) {
                case VENDOR:
                    return Collections.unmodifiableSet(new HashSet<>(vendors));
                case PRODUCT:
                    return Collections.unmodifiableSet(new HashSet<>(products));
                case VERSION:
                    return Collections.unmodifiableSet(new HashSet<>(versions));
                default:
                    break;
            }
        }
        return null;
    }
1053711
def clearData(self, type: str = '') -> None:
        
        type = normalize_type(type)
        if not type:
            self.__data.clear()
        elif type in self.__data:
            del self.__data[type]
839356
public void remove(Object e)
    {
        // Invoke Pre Remove Events

        // TODO Check for validity also as per JPA
        if (e == null)
        {
            throw new IllegalArgumentException("Entity to be removed must not be null.");
        }

        EntityMetadata metadata = getMetadata(e.getClass());

        // Create an object graph of the entity object
        ObjectGraph graph = new GraphGenerator().generateGraph(e, this, new ManagedState());

        Node node = graph.getHeadNode();

        try
        {
            lock.writeLock().lock();

            // TODO : push into action queue, get original end-point from
            // persistenceContext first!

            // Action/ExecutionQueue/ActivityQueue :-> id, name, EndPoint,
            // changed
            // state

            // Change state of node, after successful flush processing.
            node.setPersistenceDelegator(this);
            node.remove();

            // build flush stack.

            flushManager.buildFlushStack(node, EventType.DELETE);

            // Flush node.
            flush();
        }
        finally
        {
            lock.writeLock().unlock();
        }
        // clear out graph
        graph.clear();
        graph = null;

        if (log.isDebugEnabled())
        {
            log.debug("Data removed successfully for entity : " + e.getClass());
        }
    }
533518
@Override
    public void destroy(Exception e) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "destroy(exc)");
        }

        if (null != udpNetworkLayer) {
            workQueueMgr.removeChannel(udpNetworkLayer.getDatagramChannel());
            udpNetworkLayer.destroy();
            udpNetworkLayer = null;
        }

        if (udpChannel != null) {
            udpChannel.removeConnLink(this);
        }
        //
        // Cleanup anything else that needs to be cleaned up.
        //
        super.destroy(e);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "destroy(exc)");
        }
    }
276319
public <T> void evict(T entity) {
        DocumentInfo documentInfo = documentsByEntity.get(entity);
        if (documentInfo != null) {
            documentsByEntity.remove(entity);
            documentsById.remove(documentInfo.getId());
        }

        deletedEntities.remove(entity);
        if (_countersByDocId != null) {
            _countersByDocId.remove(documentInfo.getId());
        }
    }
1254475
public static void removeFromList(final Entry e) {
    e.prev.next = e.next;
    e.next.prev = e.prev;
    e.removedFromList();
  }
1176736
public function wipe($type) {
		$table = $type;
		$table = $this->safeTable($table);
		$sql = "TRUNCATE $table CASCADE";
		$this->adapter->exec($sql);
	}
114804
@Override
    public synchronized void removeUpdate(DocumentEvent e) {
        int len = e.getLength();
        int off = e.getOffset();
        if (outputMark > off) {
            if (outputMark >= off + len) {
                outputMark -= len;
            } else {
                outputMark = off;
            }
        }
    }
107548
public void deleteBulkDocsAsync(String index, String type) {
        executeBulkRequestAsync(buildDeleteBulkRequestBuilder(
                buildAllDeleteRequestBuilderList(index, type)));
    }
115644
public boolean remove (E e) {
		for (int i = 0; i < size; i++) {
			E e2 = data[i];

			if (e == e2) {
				data[i] = data[--size]; // overwrite item to remove with last element
				data[size] = null; // null last element, so gc can do its work
				return true;
			}
		}

		return false;
	}
363239
public void uncacheProxyOfEntity(final Entity e, final Class<? extends Entity> type) {
	cache.invalidateType(e, type);
    }
664047
public synchronized void addEvidence(EvidenceType type, Evidence e) {
        if (null != type) {
            switch (type) {
                case VENDOR:
                    vendors.add(e);
                    break;
                case PRODUCT:
                    products.add(e);
                    break;
                case VERSION:
                    versions.add(e);
                    break;
                default:
                    break;
            }
        }
    }
420744
public void remove() throws RemoveException, javax.ejb.EJBException
    {
        try {
            container.removeBean(this);
        } catch (java.rmi.RemoteException e) {
            FFDCFilter.processException(e, CLASS_NAME + ".remove", "132", this);
            throw new EJBException(e);
        }
    }
143745
public void remove(Class<? extends T> type) throws IOException {
        for (T t : data) {
            if(t.getClass()==type) {
                data.remove(t);
                onModified();
                return;
            }
        }
    }
601113
public function clear( $type = null ) 
	{
		if ( is_null( $type ) )
		{
			$this->assets = array();
		}
		else
		{
			if ( isset( $this->assets[$type] ) )
			{
				$this->assets[$type] = array();
			}
		}
	}