Unbinds the user events listed in the module
@param {Box.Application~ModuleInstanceData} instanceData Events will be unbound from the module defined in the Instance object
@returns {void}
@private
547538
function unbindEventListeners(instanceData) {

		var eventDelegates = instanceData.eventDelegates;

		for (var i = 0; i < eventDelegates.length; i++) {
			eventDelegates[i].detachEvents();
		}

		instanceData.eventDelegates = [];
	}
547819
function unsetInternal(that, propertyList, options) {
    if(propertyList.length === 0) throw new Error("You can't set at the top-level, setting like that only works for ObserveeChild (sub-observees created with 'get')")

    var pointer = getPropertyPointer(that.subject, propertyList)

    delete pointer.obj[pointer.key]

    var event = {type: 'unset', property: propertyList}
    if(options.data !== undefined) event.data = event.id = options.data
    that.emit('change',event)
}
201395
function(){
    var args = Array.prototype.slice.call(arguments);
    Backbone.View.prototype.undelegateEvents.apply(this, args);

    Marionette.unbindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
    Marionette.unbindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
  }
1370427
function removeBindings() {
      for (var i = 0; i < this._c.length; i++) {
        this.unbind(this._c[i].children);
      }
    }
606370
function unbindFromStrings(target, entity, evt, methods){
    var methodNames = methods.split(/\s+/);

    _.each(methodNames,function(methodName) {
      var method = target[methodName];
      target.stopListening(entity, evt, method, target);
    });
  }
83726
public static synchronized void unregisterModule(PmiModule instance) {
        if (disabled)
            return;
        if (instance == null) // || instance.getPath().length<=1) return;
            return;

        // check if the path has null in it. if a module is unregistered twice
        // the path will have null
        String[] path = instance.getPath();
        if (path == null || path.length == 0)
            return;
        for (int k = 0; k < path.length; k++) {
            if (path[k] == null)
                return;
        }

        if (tc.isEntryEnabled())
            Tr.entry(tc, "unregisterModule: " + instance.getModuleID() + ", " + instance.getName());
        // unregister itself

        String[] parentPath = new String[path.length - 1];
        System.arraycopy(path, 0, parentPath, 0, parentPath.length);
        // locate parent
        ModuleItem parent = moduleRoot.find(parentPath, 0);
        if (parent != null) {
            // remove "instance" from parent
            parent.remove(parent.find(path[path.length - 1]));
            // do not remove the empty parent group in custom pmi
            // in custom PMI groups/instances are explicitly created and
            // should be remove explicitly

            // in pre-custom groups are create IMPLICITYLY when needed
            if (instance.isCustomModule())
                return;

            // check if parent is empty
            if (parent.children == null || parent.children.size() == 0) {
                if (parent.getInstance() != null) {
                    String[] mypath = parent.getInstance().getPath();
                    // TODO: ask Wenjian about this?
                    // exclude WEBAPP_MODULE because it is created explicitly and
                    // should be removed explictly by calling PmiFactory.removePmiModule
                    if (!(mypath.length == 2 && (mypath[0].equals(WEBSERVICES_MODULE)))) {
                        // recursive call?: unregisterModule (parent.getInstance());
                        parent.getInstance().unregister();
                    }
                }
            }
        }
        if (tc.isEntryEnabled())
            Tr.exit(tc, "unregisterModule");
    }
998974
@Override
    public void deleteInstance(String instanceId) {
        modifyInstance(instanceId, map -> {
            Instance deletedInstance = map.remove(instanceId);
            getDeletedInstancesByIdMap().put(deletedInstance.getId(), deletedInstance);
        });
    }
848284
function () {
            // binding already destroyed?
            if (!this.$) {
                return;
            }
            var e;
            for (var j = 0; j < this.$events.length; j++) {
                e = this.$events[j];
                this.$.scope.unbind(e.eventType, e.callback, this);
            }

            this.$.scope.unbind('destroy', this.destroy, this);

            if (this.$.twoWay === true) {
                this.$.target.unbind(this.$.targetEvent, this._revCallback, this);
            }
            if (this.$subBinding) {
                this.$subBinding.destroy();
                this.$subBinding = null;
            }

            // destroy parameter bindings
            for (var i = 0; i < this.$parameters.length; i++) {
                var par = this.$parameters[i];
                if (par instanceof Binding) {
                    par.destroy();
                }
            }
            this.$parameters = null;
            this.$.scope = this.$.target = this.$.callback = null;
            this.$ = null;
            this.$targets = null;
            this.callBase();

            bindingsDestroyed++;
            if (bindingsDestroyed === 500) {
                if (typeof(CollectGarbage) === "function") {
                    CollectGarbage();
                }
                bindingsDestroyed = 0;
            }
        }
1260089
function() {
    this._unbindModel();
    this.map.bind('change:view_bounds_sw',  this._changeBounds, this);
    this.map.bind('change:view_bounds_ne',  this._changeBounds, this);
    this.map.bind('change:zoom',            this._setZoom, this);
    this.map.bind('change:scrollwheel',     this._setScrollWheel, this);
    this.map.bind('change:keyboard',        this._setKeyboard, this);
    this.map.bind('change:center',          this._setCenter, this);
    this.map.bind('change:attribution',     this.setAttribution, this);
  }
784273
function closeInstance(dialogue) {

  // none may be open yet, or one may be open but may be closing another which is not open
  if (typeof dialogue === 'undefined' || typeof dialogue.options === 'undefined' || !dialoguesOpen.length) {
    return;
  }

  dialoguesOpen.forEach(function(dialogueSingle, index) {
    if (dialogueSingle.options.id == dialogue.options.id) {
      dialoguesOpen.splice(index, 1);
    }
  });

  if (!dialoguesOpen.length) {
    document.removeEventListener('keyup', handleKeyup);
    document.removeEventListener('mousedown', handleMousedown);
  }

  // .off('click.dialogue.action')

  // dialogue.container.off(); // needed?
  docBody.removeChild(dialogue.container);
  dialogue.options.onClose.call(dialogue);
}
59167
function unbind (vm, key) {
  var source = vm._wilddogSources && vm._wilddogSources[key]
  if (!source) {
    throw new Error(
      'VueWild: unbind failed: "' + key + '" is not bound to ' +
      'a Wilddog reference.'
    )
  }
  var listeners = vm._wilddogListeners[key]
  for (var event in listeners) {
    source.off(event, listeners[event])
  }
  vm[key] = null
  vm.$wilddogRefs[key] = null
  vm._wilddogSources[key] = null
  vm._wilddogListeners[key] = null
}
722319
function bindEventListeners(instanceData) {
		var eventDelegates = instanceData.eventDelegates,
			moduleBehaviors = getBehaviors(instanceData);

		// bind the module events
		createAndBindEventDelegate(eventDelegates, instanceData.element, instanceData.instance);

		// bind the behavior(s) events
		for (var i = 0; i < moduleBehaviors.length; i++) {
			createAndBindEventDelegate(eventDelegates, instanceData.element, moduleBehaviors[i]);
		}
	}
620876
function (instance) {
                    window.clearTimeout(privateData.reconnectTimeoutId);
                    privateData.reconnectTimeoutId = null;

                    if (changeState(instance,
                                    signalR.connectionState.reconnecting,
                                    signalR.connectionState.connected) === true) {
                        // Successfully reconnected!
                        instance.log("Raising the reconnect event");
                        $(instance).triggerHandler(events.onReconnect);
                    }
                }
885757
function() {
      if (!this._unbound) {
        log.unbind && console.log('[%s] asyncUnbindAll', this.localName);
        this._unbindAllJob = this.job(this._unbindAllJob, this.unbindAll, 0);
      }
    }
808464
function bindEventListeners(instanceData) {
		var i,
			j,
			type,
			eventHandlerName,
			eventHandlerFunctions,
			moduleBehaviors = getBehaviors(instanceData);

		for (i = 0; i < eventTypes.length; i++) {
			eventHandlerFunctions = [];

			type = eventTypes[i];
			eventHandlerName = 'on' + type;

			// Module's event handler gets called first
			if (instanceData.instance[eventHandlerName]) {
				eventHandlerFunctions.push($.proxy(instanceData.instance[eventHandlerName], instanceData.instance));
			}

			// And then all of its behaviors in the order they were declared
			for (j = 0; j < moduleBehaviors.length; j++) {
				if (moduleBehaviors[j][eventHandlerName]) {
					eventHandlerFunctions.push($.proxy(moduleBehaviors[j][eventHandlerName], moduleBehaviors[j]));
				}
			}

			if (eventHandlerFunctions.length) {
				instanceData.eventHandlers[type] = bindEventType(instanceData.element, type, eventHandlerFunctions);
			}
		}
	}
722998
function removeBinding(oBindingInfo) {
			// Also tell the Control that the messages have been removed (if any)
			if (that.refreshDataState) {
				that.refreshDataState(sName, oBindingInfo.binding.getDataState());
			}

			oBindingInfo.binding.detachChange(oBindingInfo.modelChangeHandler);
			if (oBindingInfo.modelRefreshHandler) { // only list bindings currently have a refresh handler attached
				oBindingInfo.binding.detachRefresh(oBindingInfo.modelRefreshHandler);
			}
			oBindingInfo.binding.detachEvents(oBindingInfo.events);
			oBindingInfo.binding.destroy();
			// remove all binding related data from the binding info
			delete oBindingInfo.binding;
			delete oBindingInfo.modelChangeHandler;
			delete oBindingInfo.dataStateChangeHandler;
			delete oBindingInfo.modelRefreshHandler;
		}
352796
function (el, ev, callback) {

        can.bind.call(el, ev, callback);

        return function () {
            can.unbind.call(el, ev, callback);
        };
    }