Deletes the given entity instance (specified by its id). The instance is removed from the persistent layer.

@param id the id
963723
@Override
    public void delete(final I id) {
        if (entity != null) {
            inTransaction(
                    new Callable<Void>() {
                        @Override
                        public Void call() throws Exception {
                            final T entity = findOne(id);
                            T attached = getAttached(entity);
                            if (attached != null) {
                                entityManager.remove(attached);
                            }
                            return null;
                        }
                    }
            );
        }
    }
487981
public function destroy($id)
    {
        $this->_table->delete(new Entity(
            [$this->_table->getPrimaryKey() => $id],
            ['markNew' => false]
        ));

        return true;
    }
651585
public void delete(Class clazz, Object identifier) {
        try {
            //noinspection ConstantConditions
            persistenceManager.deleteEntity(persistenceManager.findById(clazz, identifier));
        } catch (InitializationException ignore){}
        catch (Exception e) {
            e.printStackTrace();
        }

    }
785274
public void remove(Id id) {
        readCache.remove(new CacheKey(id));
        writeCache.remove(id);
    }
634834
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<E> delete(@PathVariable int id) {

        try {
            E entityToDelete = this.service.findById(id);

            this.service.delete(entityToDelete);

            // extract the original classname from the name of the proxy, which
            // also contains _$$_ and some kind of hash after the original
            // classname
            final String proxyClassName = entityToDelete.getClass().getSimpleName();
            final String simpleClassName = StringUtils.substringBefore(proxyClassName, "_$$_");

            LOG.trace("Deleted " + simpleClassName + " with ID " + id);
            return new ResponseEntity<E>(HttpStatus.NO_CONTENT);
        } catch (Exception e) {
            LOG.error("Error deleting entity with ID " + id + ": "
                + e.getMessage());
            return new ResponseEntity<E>(HttpStatus.NOT_FOUND);
        }
    }
103195
public function remove($id)
    {
        $this->client->delete(Inflector::pluralize($this->getResourceName()).'/'.$id);
    }
612020
public synchronized void removeObject(String id) {

        m_cache = null;
        if (m_relativeOrdered) {
            if (m_uniqueIds) {
                Object o = getObject(id);
                Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
                while (itObjs.hasNext()) {
                    CmsIdObjectElement<T> object = itObjs.next();
                    if (object.getObject() == o) {
                        itObjs.remove();
                        break;
                    }
                }
                m_objectsById.remove(id);
            } else {
                Iterator<T> itRemove = m_objectsListsById.get(id).iterator();
                while (itRemove.hasNext()) {
                    T o = itRemove.next();
                    Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
                    while (itObjs.hasNext()) {
                        CmsIdObjectElement<T> object = itObjs.next();
                        if (object.getObject() == o) {
                            itObjs.remove();
                            break;
                        }
                    }
                }
                m_orderedObjectList.remove(id);
            }
        } else {
            Object o = getObject(id);
            m_objectList.remove(o);
            if (m_uniqueIds) {
                m_objectsById.remove(id);
            } else {
                m_objectsListsById.remove(id);
            }
        }
    }
1207496
@Override
    public void deleteById(ID id) {
        Assert.notNull(id, "id to be deleted should not be null");

        operation.deleteById(information.getCollectionName(), id, null);
    }
953184
public void delete(E e) {
        LOG.trace("Deleting " + entityClass.getSimpleName() + " with ID " + e.getId());
        getSession().delete(e);
    }
661845
public function delete(int $id): void
    {
        $this->getClient()->call(null, $id, self::ENDPOINT, null, false, 'DELETE');
    }
1183503
function(id) {
    if(this.hasNode(id)) {
      delete this.nodes[id];
      var adjs = this.edges[id];
      for(var to in adjs) {
        delete this.edges[to][id];
      }
      delete this.edges[id];
    }
  }
642636
public synchronized boolean remove(int id)
   {
		if (tc.isEntryEnabled()) SibTr.entry(this, tc, "remove", ""+id);
      
      final boolean result = contains(id);
      if (result)
      {
         mutableKey.setValue(id);
         idToConvTable.remove(mutableKey);
      }
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", ""+result);
      return result;
   }
846184
public void document_id_DELETE(String id) throws IOException {
		String qPath = "/me/document/{id}";
		StringBuilder sb = path(qPath, id);
		exec(qPath, "DELETE", sb.toString(), null);
	}
8513
public void remove (int objectID) {
		Object object = idToObject.remove(objectID);
		if (object != null) objectToID.remove(object, 0);
		if (TRACE) trace("kryonet", "Object " + objectID + " removed from ObjectSpace: " + object);
	}
598459
public void deleteEvse(Long chargingStationTypeId, Long id) {
        ChargingStationType chargingStationType = chargingStationTypeRepository.findOne(chargingStationTypeId);

        chargingStationType.getEvses().remove(getEvseById(chargingStationType, id));

        updateChargingStationType(chargingStationType.getId(), chargingStationType);
    }
723791
public void remove(String id) {
		final Lock writeLock = lock.writeLock();
		try {
			writeLock.lock();
			final int index = ids.indexOf(id);
			if (index > -1) {
				tasks.remove(index);
				patterns.remove(index);
				ids.remove(index);
				size--;
			}
		} finally {
			writeLock.unlock();
		}
	}
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()