This method is invoked by iPojo every time a monitoring handler disappears.
@param handler the disappearing monitoring handler
434994
public void handlerDisappears( IMonitoringHandler handler ) {

		// May happen if a target could not be instantiated
		// (iPojo uses proxies). In this case, it results in a NPE here.
		if( handler == null ) {
			this.logger.info( "An invalid monitoring handler is removed." );
		} else {
			this.handlers.remove( handler );
			this.logger.info( "Monitoring handler '" + handler.getName() + "' is not available anymore." );
		}

		listHandlers( this.handlers, this.logger );
	}
442469
public void deleteToken(String token, DeleteTokenHandler handler) {
        HMSAgentLog.i("deleteToken:token:" + StrUtils.objDesc(token) + " handler=" + StrUtils.objDesc(handler));
        this.token = token;
        this.handler = handler;
        connect();
    }
804233
public static void listHandlers( List<IMonitoringHandler> handlers, Logger logger ) {

		if( handlers.isEmpty()) {
			logger.info( "No monitoring handler was found." );

		} else {
			StringBuilder sb = new StringBuilder( "Available monitoring handlers: " );
			for( Iterator<IMonitoringHandler> it = handlers.iterator(); it.hasNext(); ) {
				sb.append( it.next().getName());
				if( it.hasNext())
					sb.append( ", " );
			}

			sb.append( "." );
			logger.info( sb.toString());
		}
	}
434331
function(type, handler) {
            var self = this,
                proxy = function (event) {
                    self.off(type, proxy);
                    handler.call(self, event);
                };
            proxy.handler = handler;
            this.on(type, proxy);
        }
447935
public static void replaceDefaultHandler(Handler handler) {
    Logger rootlogger = LogManager.getLogManager().getLogger("");
    for(Handler h : rootlogger.getHandlers()) {
      if(h instanceof CLISmartHandler) {
        rootlogger.removeHandler(h);
      }
    }
    addHandler(handler);
  }
651238
public final <T> void registerType(Class<T> runtimeClass, TypeHandler<T> handler) {
        if (started) {
            // Can't add any more metrics anyway; harmless
            return;
        }
        typeHandlers.put(runtimeClass, handler);
    }
818881
protected void assignDataToHandler(ServerHandlerClass handler, Object instance) {
	    if(getParentExtension().getConfigProperties() != null) {
	        new ConfigPropertyDeserializer().deserialize(
	                handler.getPropertiesClassWrapper(), 
	                instance, 
	                getParentExtension().getConfigProperties());
	    }
    }
1008159
public void init(CmsBinaryPreviewHandler handler) {

        m_handler = handler;
        final CmsPropertiesTab propTab = new CmsPropertiesTab(m_galleryMode, m_dialogHeight, m_dialogWidth, m_handler);
        m_selectButton.addClickHandler(new ClickHandler() {

            public void onClick(ClickEvent event) {

                saveChanges(null);

            }
        });
        m_propertiesTab = propTab;
        m_tabbedPanel.add(m_propertiesTab, Messages.get().key(Messages.GUI_PREVIEW_TAB_PROPERTIES_0));
    }
1129900
@Override
    public ReadStream<Buffer> handler(Handler<Buffer> handler) {
        if (handler == null) {
            throw new IllegalArgumentException("handler");
        }
        this.dataHandler = handler;
        doRead();
        return this;
    }
519730
private void initRepairingHandler(RepairingHandler handler) {
        logger.finest("Initializing repairing handler");

        boolean initialized = false;
        try {
            invalidationMetaDataFetcher.init(handler);
            initialized = true;
        } catch (Exception e) {
            logger.warning(e);
        } finally {
            if (!initialized) {
                initRepairingHandlerAsync(handler);
            }
        }
    }
384600
public void setHandler(final Class<? extends Throwable> clas, final JKExceptionHandler handler) {
		this.handlers.put(clas, handler);
	}
710652
protected void addPubSubOutputHandler(PubSubOutputHandler handler)
  {
    if (iPubSubOutputHandlers == null)
      iPubSubOutputHandlers = new HashSet();

    // Add the PubSubOutputHandler to the list that this neighbour
    // knows about.  This is so a recovered neighbour can add the list of
    // output handlers back into the matchspace.
    iPubSubOutputHandlers.add(handler);
  }
973775
@Override
    public HandlerRegistration addChangeHandler(final ChangeHandler handler) {
        return getRangeInputElement().addDomHandler(handler, ChangeEvent.getType());
    }
172812
public synchronized void setHandler(Handler handler) {
        String handlerId = CollectorManagerUtils.getHandlerId(handler);
        HandlerManager hdlrMgr;
        if (!handlerMgrs.containsKey(handlerId)) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(tc, "Adding handler to the list", handler.getClass());
            }
            hdlrMgr = new HandlerManager(handler);
            handlerMgrs.put(hdlrMgr.getHandlerId(), hdlrMgr);
            hdlrMgr.getHandler().init(this);
        }
    }
773682
public void removeNotificationHandler(String serviceName, NotificationHandler handler) {

        ServiceInstanceUtils.validateServiceName(serviceName);
        if (handler == null) {
            throw new ServiceException(ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR,
                    ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR.getMessageTemplate(),
                    "NotificationHandler");
        }
        List<InstanceChangeListener<ModelServiceInstance>> list = changeListenerMap.get(serviceName);
        if (list != null) {
            boolean found = false;
            for (InstanceChangeListener<ModelServiceInstance> listener : list) {
                if (listener instanceof NotificationHandlerAdapter
                        && ((NotificationHandlerAdapter) listener).getAdapter() == handler) {
                    list.remove(listener);
                    found = true;
                    break;
                }
            }
            if (!found) {
               LOGGER.error(ErrorCode.NOTIFICATION_HANDLER_DOES_NOT_EXIST.getMessageTemplate());
            }
        } else {
            LOGGER.error(String.format(ErrorCode.SERVICE_DOES_NOT_EXIST.getMessageTemplate(), serviceName));
        }

    }
775130
void removeHandler( Object handlerRegistration )
	{
		// Through object's interface implementation
		if( handlerRegistration instanceof DirectHandlerInfo )
		{
			DirectHandlerInfo info = (DirectHandlerInfo) handlerRegistration;
			info.source.removePropertyChangedHandler( info.registrationObject );
			return;
		}
		
		if( ! ( handlerRegistration instanceof HandlerInfo ) )
			return;
		
		HandlerInfo info = (HandlerInfo) handlerRegistration;
	
		HashMap<String, ArrayList<PropertyChangedHandler>> handlersMap = PlatformSpecificProvider.get().getObjectMetadata( info.source );
		if( handlersMap == null )
			return;
	
		ArrayList<PropertyChangedHandler> handlerList = handlersMap.get( info.propertyName );
		if( handlerList == null )
			return;
	
		handlerList.remove( info.handler );
	
		if( handlerList.isEmpty() )
			handlersMap.remove( info.propertyName );
	
		if( handlersMap.isEmpty() )
			PlatformSpecificProvider.get().setObjectMetadata( info.source, null );
		
		stats.statsRemovedRegistration( info );
	
		info.handler = null;
		info.propertyName = null;
		info.source = null;
	}
298916
protected void notifyToHandler(ServerHandlerClass handler, 
            ApiZone zone, ApiBuddyImpl buddy) {
        ReflectMethodUtil.invokeHandleMethod(
                handler.getHandleMethod(), 
                handler.newInstance(), 
                context, zone, buddy);
    }