Checks if the given entity is marked with status DELETED. Returns
        `False` if the entity has no state information.
555455
def is_marked_deleted(self, entity):
        
        try:
            result = EntityState.get_state(entity).status \
                                                    == ENTITY_STATUS.DELETED
        except ValueError:
            result = False
        return result
569049
final public function isDeleted() {
        foreach ($this->dao()->getMapping()['properties'] as $name => $property) {
            if (isset($property['soft-delete']) && $property['soft-delete']===true) {
                return ($this->$name !== null);
            }
        }
        return false;
    }
1350060
function isDeleted(type, id) {
    var typeInfo = getTypeInfo(type);

    return db.get(serialize(typeInfo.documentType, id))
      .then(function (doc) { return !!doc._deleted; })
      .catch(function (err) { return err.reason === "deleted" ? true : null; });
  }
966651
function isDeleted(metadata, rev) {
  if (!rev) {
    rev = winningRev(metadata);
  }
  var id = rev.substring(rev.indexOf('-') + 1);
  var toVisit = metadata.rev_tree.map(getTrees);

  var tree;
  while ((tree = toVisit.pop())) {
    if (tree[0] === id) {
      return !!tree[1].deleted;
    }
    toVisit = toVisit.concat(tree[2]);
  }
}
387315
def mark_clean(self, entity):
        
        state = EntityState.get_state(entity)
        state.status = ENTITY_STATUS.CLEAN
        state.is_persisted = True
1093807
boolean isEmpty(String repoFullName) {
    lock.readLock().lock();
    try {
      verifyRepoRegistered(repoFullName);
      return entityListenersByRepo.get(repoFullName).isEmpty();
    } finally {
      lock.readLock().unlock();
    }
  }
1036665
def is_none(entity, prop, name):
    ""
    return is_not_empty(entity, prop, name) and getattr(entity, name) is None
925281
def deleted(self):
        
        query = queries.build_query({**self.spec,
                                     'future': False,
                                     '_deleted': True})
        return [Entry(e) for e in query]
361575
public boolean isDeleted() {
        boolean deleted = true;
        for (PolygonMarkers polygon : polygonMarkers) {
            deleted = polygon.isDeleted();
            if (!deleted) {
                break;
            }
        }
        return deleted;
    }
620621
@Override
    public boolean isRemoved() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "isRemoved : false");
        return false;
    }
1037017
function onEntityDeleted( serverResponse ) {
			self.__cacheMaintain( self.__entityCacheRaw[ configuration.collectionName || configuration.entityName ],
				entity,
				"delete",
				false );

			return self.__removeEntityFromCache( entityId );
		}
520866
def get_status(self, instance):
        
        status_key, status = self._get_status(instance)
        if status['state'] in ['complete', 'error']:
            cache.delete(status_key)
        return status
135606
public final Boolean isDeleted() {
        Boolean deleted = getObject(DELETED_CONST, Boolean.class);
        return deleted != null ? deleted : false;
    }
77518
public boolean isToBeDeleted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "isToBeDeleted");
            SibTr.exit(tc, "isToBeDeleted", Boolean.valueOf(toBeDeleted));
        }

        return toBeDeleted;
    }
502141
boolean contains(Object entity)
    {
        Node node = getPersistenceCache().getMainCache().getNodeFromCache(entity, getMetadata(entity.getClass()), this);
        return node != null && node.isInState(ManagedState.class);
    }
301680
public boolean isDeleted(Cell cell)
    {
        int idx = searchInternal(cell.name(), 0);
        // No matter what the counter cell's timestamp is, a tombstone always takes precedence. See CASSANDRA-7346.
        return idx >= 0 && (cell instanceof CounterCell || markedAts[idx] >= cell.timestamp());
    }
516457
public static boolean isSingletonEntity(EntityDataModel entityDataModel, Object entity) throws ODataEdmException {
        // Get the entity type
        EntityType entityType = getAndCheckEntityType(entityDataModel, entity.getClass());
        boolean isSingletonEntity = false;

        for (Singleton singleton : entityDataModel.getEntityContainer().getSingletons()) {
            if (singleton.getTypeName().equals(entityType.getFullyQualifiedName())) {
                isSingletonEntity = true;
                break;
            }
        }

        return isSingletonEntity;
    }