Unmarks this object.

Used for deciding if this object is to be deleted.
The object is marked, the proxies are all reregistered.
If there is a mark still left, then this proxy can be deleted.
180126
void unmark()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "unmark");
      SibTr.exit(tc, "unmark");
    }

    _marked = false;
  }
701931
final public function destroy()
    {
        foreach ($this->registry as $offset => $object) {
            if (method_exists($object, '__destruct')) {
                $object->__destruct();
            }
            unset($this->registry[ $offset ]);
        }
    }
759153
public boolean remove()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");

        boolean reply = iterator.remove();

        if (reply)
        {
            size--;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", "reply=" + reply);
        return reply;
    }
1067157
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            # Check if the model is actually registered (``get_options_for_model``
            # throws an exception if it's not).
            self.get_options_for_model(model)
            # Invalidate all submodels options and forget about
            # the model itself.
            for desc, desc_opts in list(self._registry.items()):
                if not issubclass(desc, model):
                    continue
                if model != desc and desc_opts.registered:
                    # Allowing to unregister a base would necessitate
                    # repatching all submodels.
                    raise DescendantRegistered(
                        'You need to unregister descendant "%s" before'
                        ' unregistering its base "%s"' %
                        (desc.__name__, model.__name__))
                del self._registry[desc]
1238416
def unregister(self):
        
        if self.registered:
            #Only if we have not received any message recently.
            if datetime.datetime.now()-datetime.timedelta(seconds=self.unregister_timeout) > self.lastmsg:
                self.registered = False
                if self.parent:
                    self.parent.unregister(self)
1243055
protected void unmark(final int level) {
        assert level <= this.seen.size();
        while (level < this.seen.size()) {
            final int lit = this.seen.back();
            this.seen.pop();
            final CLVar v = var(lit);
            assert v.mark() == sign(lit);
            v.setMark(0);
        }
    }
927480
def del_object_from_parent(self):
        
        if self.parent:
            self.parent.objects.pop(self.ref)
320681
function cleanupProxyOnDestroy (object) {
      if (api.mediaCapturer && api.mediaCapturer.id === object.id) {
        api.mediaCapturer = null;
      }
      else if (proxies.hasOwnProperty(object.id)) {
        delete proxies[object.id];
      }

      if (object.$) {
        object.$.remove();
      }
    }
1001513
public synchronized boolean unregisterObject(Object object) {
        int i = MiscUtil.indexOfInstance(registeredObjects, object);
        
        if (i > -1) {
            registeredObjects.remove(i);
            
            for (IRegisterEvent onRegister : onRegisterList) {
                onRegister.unregisterObject(object);
            }
            
            if (object instanceof IRegisterEvent) {
                onRegisterList.remove(object);
            }
            
            return true;
        }
        
        return false;
    }
817116
void markNodesRemovedIfUnreachable() {
        EdgeExplorer edgeExplorer = ghStorage.createEdgeExplorer();
        for (int nodeIndex = 0; nodeIndex < ghStorage.getNodes(); nodeIndex++) {
            if (detectNodeRemovedForAllEncoders(edgeExplorer, nodeIndex))
                ghStorage.markNodeRemoved(nodeIndex);
        }
    }
270553
public void clearProxyObject (int origObjectId, DObject object)
    {
        if (_proxies.remove(object.getOid()) == null) {
            log.warning("Missing proxy mapping for cleared proxy", "ooid", origObjectId);
        }
        _objects.remove(object.getOid());
    }
1165245
public boolean delete(Marker marker) {
        boolean deleted = false;
        if (contains(marker)) {
            deleted = true;
            ShapeMarkers shapeMarkers = shapeMarkersMap.remove(marker.getId());
            if (shapeMarkers != null) {
                shapeMarkers.delete(marker);
            }
            marker.remove();
        }
        return deleted;
    }
101797
def delete(self):
        
        if self._new:
            raise Exception("This is a new object, %s not in data, \
indicating this entry isn't stored." % self.primaryKey)

        r.table(self.table).get(self._data[self.primaryKey]) \
            .delete(durability=self.durability).run(self._conn)
        return True
677755
public void markUnresolvable(EObject referenced) {
		if (!referenced.eIsProxy()) {
			throw new IllegalArgumentException("Cannot mark an instance as unresolvable if it is already resolved");
		}
		URI proxyURI = ((InternalEObject)referenced).eProxyURI();
		getUnresolvableURIFragments().add(proxyURI.fragment());
	}
288415
def clear_rules_from_all_proxies(self):
        
        self._queue = []        
        if self.debug:
            print 'Clearing rules'
        for service in self.app.get_services():
            for instance in self.app.get_service_instances(service):
                if self.debug:
                    print 'Clearing rules for %s - instance %s' % (service, instance)
                resp = requests.delete("http://{}/gremlin/v1/rules".format(instance))
                if resp.status_code != 200:
                    print 'Failed to clear rules for %s - instance %s' % (service, instance)
47143
def deleteUnused(self):
        
        if self.dryrun:
            self._client.listUnused()
        else:
            self._client.deleteUnused()
227373
private void removeInstance() {
        // unregister client
        ClientRegistry ref = registry.get();
        if (ref != null) {
            ref.removeClient(this);
        } else {
            log.warn("Client registry reference was not accessable, removal failed");
            // TODO: attempt to lookup the registry via the global.clientRegistry
        }
    }