Removes the specified entry listener. Returns silently if there is no such listener added before.

        :param registration_id: (str), id of registered listener.
        :return: (bool), ``true`` if registration is removed, ``false`` otherwise.
508406
def remove_entry_listener(self, registration_id):
        
        return self._stop_listening(registration_id,
                                    lambda i: map_remove_entry_listener_codec.encode_request(self.name, i))
192737
public function unRegisterEvents()
    {
        if (is_array($this->events()) && count($this->events()))
        {
            $event = new Event($this);
            return $event->remove();
        }
        return true;
    }
1089075
protected boolean register(IEventListener listener) {
        log.debug("register - listener: {}", listener);
        boolean registered = listeners.add(listener);
        if (registered) {
            listenerStats.increment();
            // prepare response for new client
            ownerMessage.addEvent(Type.CLIENT_INITIAL_DATA, null, null);
            if (!isPersistent()) {
                ownerMessage.addEvent(Type.CLIENT_CLEAR_DATA, null, null);
            }
            if (!attributes.isEmpty()) {
                ownerMessage.addEvent(new SharedObjectEvent(Type.CLIENT_UPDATE_DATA, null, getAttributes()));
            }
            // we call notifyModified here to send response if we're not in a beginUpdate block
            notifyModified();
        }
        return registered;
    }
1122141
public static void removeRegistrationId(Context context) {
        final SharedPreferences prefs = getGcmPreferences(context);
        prefs.edit()
                .remove(PROPERTY_REG_ID)
                .remove(PROPERTY_APP_VERSION)
                .apply();
    }
141071
public void unregister(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			this.handlersByEventType.removeAll(clazz);
		}
	}
221816
public static <T> boolean removeFromList(T listener, List<? extends ListenerRegistration<T>> list) {
        checkNotNull(listener);

        ListenerRegistration<T> item = null;
        for (ListenerRegistration<T> registration : list) {
            if (registration.listener == listener) {
                item = registration;
                break;
            }
        }
        return item != null && list.remove(item);
    }
1098593
def unregister_view(self):
        
        for handler_id in self.handler_ids.keys():
            self.view[handler_id].disconnect(self.handler_ids[handler_id])
656097
function unregister() {
    if (!applicationCurrent) {
        return;
    }
    applicationCurrent.stop();

    EVENTS.forEach(function (event) {
        process.removeListener(event, currentHandlers[event]);
    });

    applicationCurrent = null;
    currentHandlers = {};
}
405578
def unregister(self, handler):
        
        for handler_obj in self.handlers:
            registered = handler_obj.handler
            if handler is registered:
                self.handlers.remove(handler_obj)
                return True
        raise ValueError('This handler is not registered!')
1272427
@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
    public void unregisterCaller(Identification identification) {
        if(!callers.containsKey(identification)) return;
        callers.get(identification).localEvents = null;
        callers.remove(identification);
    }
645728
function (inst) {
	    var key = getDictionaryKey(inst);
	    for (var registrationName in listenerBank) {
	      if (!listenerBank.hasOwnProperty(registrationName)) {
	        continue;
	      }

	      if (!listenerBank[registrationName][key]) {
	        continue;
	      }

	      var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
	      if (PluginModule && PluginModule.willDeleteListener) {
	        PluginModule.willDeleteListener(inst, registrationName);
	      }

	      delete listenerBank[registrationName][key];
	    }
	  }
903825
def remove(mode_id: str) -> bool:
    

    had_mode = has(mode_id)

    if had_mode:
        _current_modes.remove(mode_id)

    return had_mode
1101271
def unregister(self, provider):
        '''
        '''
        if isinstance(provider, type):
            provider = provider()
        if isinstance(provider, DataProvider):
            provider = provider.code
        return self.pop(str(provider).upper(), None)
138095
public void cancel() {
    List<CancellationTokenRegistration> registrations;
    synchronized (lock) {
      throwIfClosed();
      if (cancellationRequested) {
        return;
      }

      cancelScheduledCancellation();

      cancellationRequested = true;
      registrations = new ArrayList<>(this.registrations);
    }
    notifyListeners(registrations);
  }
1128109
def unregister(self, id):
        '''
        
        '''
        result = self.rr.table(self.table).get(id).delete().run()
        if result != {
                'deleted':1, 'errors':0,'inserted':0,
                'replaced':0,'skipped':0,'unchanged':0}:
            self.logger.warn(
                    'unexpected result attempting to delete id=%s from '
                    'rethinkdb services table: %s', id, result)
1324720
def unregister_listener(self, address, func):
        
        listeners = self.address_listeners[address]
        if listeners is None:
            return False

        if func in listeners:
            listeners.remove(func)
            return True

        return False
1247326
private void unregisterInternal(final JobID id) {

		// Use spin lock here
		while (this.lockMap.putIfAbsent(id, LOCK_OBJECT) != null);

		if (decrementReferenceCounter(id) == 0) {
			this.libraryManagerEntries.remove(id);
		}

		this.lockMap.remove(id);
	}