Unbinds a controller.

@param controller the controller
767980
@Unbind(aggregate = true)
    public synchronized void unbindController(Controller controller) {
        LOGGER.info("Removing routes from " + controller);
        Collection<RouteDelegate> copy = new LinkedHashSet<>(routes);
        for (RouteDelegate r : copy) {
            if (r.getControllerObject().equals(controller)) {
                routes.remove(r);
            }
        }
    }
336614
@Bind(aggregate = true, optional = true)
    public synchronized void bindController(Controller controller) {
        LOGGER.info("Adding routes from " + controller);

        List<Route> newRoutes = new ArrayList<>();
        try {

            List<Route> annotatedNewRoutes = RouteUtils.collectRouteFromControllerAnnotations(controller);
            newRoutes.addAll(annotatedNewRoutes);
            newRoutes.addAll(controller.routes());

            //check if these new routes don't pre-exist
            ensureNoConflicts(newRoutes);

        } catch (RoutingException e) {
            LOGGER.error("The controller {} declares routes conflicting with existing routes, " +
                    "the controller is ignored, reason: {}", controller, e.getMessage(), e);
            // remove all new routes as one has failed
            routes.removeAll(newRoutes);  //NOSONAR
        } catch (Exception e) {
            LOGGER.error("The controller {} declares invalid routes, " +
                    "the controller is ignored, reason: {}", controller, e.getMessage(), e);
            // remove all new routes as one has failed
            routes.removeAll(newRoutes); //NOSONAR
        }
    }
1349189
function(controller) {
      // TODO listening?
      this.__ul.removeChild(controller.__li);
      this.__controllers.splice(this.__controllers.indexOf(controller), 1);
      const _this = this;
      common.defer(function() {
        _this.onResize();
      });
    }
117915
function __bindController (newController, sessionExpiration) {
    if (controller && typeof(controller.shutdown) === 'function') {
        controller.shutdown();
    }
    controller = newController;
    if (typeof(controller.clientInit) === 'function') {
        controller.clientInit(sessionExpiration);
    }
}
713702
def unregister_controllers(self):
        
        # TODO(xpconanfan): actually record these errors instead of just
        # logging them.
        for name, module in self._controller_modules.items():
            logging.debug('Destroying %s.', name)
            with expects.expect_no_raises(
                    'Exception occurred destroying %s.' % name):
                module.destroy(self._controller_objects[name])
        self._controller_objects = collections.OrderedDict()
        self._controller_modules = {}
340972
public function initialize(Controller $controller) {
		$this->_controller = $controller;
		if (!$this->_controller->Components->loaded('RequestHandler')) {
			$this->_controller->RequestHandler = $this->_controller->Components->load('RequestHandler');
			$this->_controller->RequestHandler->initialize($this->_controller);
		}
	}
717617
def unbind(*instances)
      service_bindings.each do |b|
        if instances.include? b.service_instance
          b.delete!
        end
      end

      self
    end
1026119
@Override
    public void onDestroy() {
        super.onDestroy();
        eventRegister.unregisterEventBuses();

        if (getControllerClass() != null) {
            try {
                Mvc.graph().dereference(controller, getControllerClass(), null);
            } catch (ProviderMissingException e) {
                //should never happen
                Logger logger = LoggerFactory.getLogger(getClass());
                logger.warn("Failed to dereference controller " + getControllerClass().getName(), e);
            }
        }

        Mvc.graph().release(this);

        Mvc.graph().unregisterMonitor(graphMonitor);
    }
1304867
private void unbind(IActionTarget target) {
        if (targets.remove(target) && targets.isEmpty()) {
            getEventManager().unsubscribe(eventName, this);
        }
    }
709633
def close(self):
    """"""
    if self._controller is not None:
      self._controller.quit()
      self._controller = None
    if self._process is not None:
      self._process.close()
      self._process = None
1271443
public void removeCursorController(GVRCursorController controller)
    {
        controller.setEnable(false);
        controllers.remove(controller);
        controller.getGVRContext().getEventManager().sendEvent(this, ICursorControllerListener.class,
                "onCursorControllerRemoved", controller);
    }
175243
@Closed(BROWSER_WATCH_SOCKET)
	public void removedClient(@Parameter("client") String client) {
		displayedControllers.inverse().remove(client);
	}
543839
public void unbind(final ValidationObject validationObject, final ProxyField proxyField, final FieldReference fieldReference, final ValidationObject owner)
    {
        final RuleProxyField ruleProxyField = getRuleProxyField(proxyField);
        for (Rule rule: fieldReference.getListeners())
        {
            RuleContext ruleContext;
			try {
				ruleContext = getRuleContext(rule,validationObject,(owner==null)?validationObject:owner);
			} catch (FailsToMatchException e) {
				continue;
			}
            ruleProxyField.removeInputRule(ruleContext);
        }
        removeRuleProxyField(proxyField);
    }
556791
public static void unbind(final Context _ctx,
                              final String _nameStr)
        throws NamingException
    {
        final Name names = _ctx.getNameParser("").parse(_nameStr);
        if (names.size() > 0)  {
            _ctx.unbind(names);
        }
    }
384433
def close!(controller)
      self.each_with_rescue(@@klasses) {|klass| klass.close!(controller)}
      self.each_with_rescue(Footnotes.after_hooks) {|hook| hook.call(controller, self)}
    end
68669
public static void cleanup(Driver driver) {
        try {
            DriverManager.deregisterDriver(driver);
        } catch (SQLException ex) {
            LOGGER.debug("An error occurred unloading the database driver", ex);
        } catch (Throwable unexpected) {
            LOGGER.debug("An unexpected throwable occurred unloading the database driver", unexpected);
        }
    }
16398
public void unbind(T service, Map<String, Object> props) {
    synchronized (serviceMap) {
      serviceMap.remove(ServiceUtil.getComparableForServiceRanking(props));
      updateSortedServices();
    }
  }