Gets a command handler instance.

Handler instances are lazy-instantiated.
498467
public function getHandler(string $handler): Handler
    {
        if (!isset($this->handlers[$handler])) {
            if (!class_exists($handler) || !class_implements($handler, Handler::class)) {
                throw new \RuntimeException("No handler found for '$handler'.");
            }

            $instance = new $handler();
            $this->handlers[$handler] = $instance;
        } else {
            $instance = $this->handlers[$handler];
        }

        return $instance;
    }
29011
public SIMPMessageHandlerControllable getMessageHandler()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getMessageHandler");
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getMessageHandler", handlerControl);

    return handlerControl ;      
  }
1006848
public HandlerType<HandlerChainType<T>> getOrCreateHandler()
   {
      List<Node> nodeList = childNode.get("handler");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new HandlerTypeImpl<HandlerChainType<T>>(this, "handler", childNode, nodeList.get(0));
      }
      return createHandler();
   }
330412
def _get_handler(self, node_id):
        """"""
        handler = self._get_attrs(node_id).get(self.HANDLER, self._default_handler)

        # Here we make sure the handler is an instance of `BasicNodeHandler` or inherited
        # types. While generally being bad Python practice, we still need it here as an
        # invalid handler can cause IDA to crash.
        if not isinstance(handler, BasicNodeHandler):
            idaapi.msg(("Invalid handler for node {}: {}. All handlers must inherit from"
                        "`BasicNodeHandler`.").format(node_id, handler))
            handler = self._default_handler
        return handler
753671
def get_handler(self, *args, **options):
        
        handler = WSGIHandler()
        try:
            from django.contrib.staticfiles.handlers import StaticFilesHandler
        except ImportError:
            return handler
        use_static_handler = options.get('use_static_handler', True)
        insecure_serving = options.get('insecure_serving', False)
        if (settings.DEBUG and use_static_handler or
                (use_static_handler and insecure_serving)):
            handler = StaticFilesHandler(handler)
        return handler
1109535
public function getHandler()
    {
        if (!$this->handler) {
            return $this->getDefaultHandler();
        }

        if (is_callable($this->handler)) {
            $this->handler = call_user_func($this->handler);
        }

        return $this->handler;
    }
553097
def get_handler(self):
        

        gcl_client = gcl_logging.Client(
            project=self.project_id, credentials=self.credentials)
        handler = gcl_handlers.CloudLoggingHandler(
            gcl_client,
            resource=self.resource,
            labels={
                'resource_id': self.instance_id,
                'resource_project': self.project_id,
                'resource_zone': self.zone,
                'resource_host': self.hostname
            })
        handler.setFormatter(self.get_formatter())
        self._set_worker_thread_level()
        return handler
1003604
def get_request_handler(self):
        
        assert self.request_handler is not None, \
            'Please define a request_handler ' \
            ' for Endpoint: %s' % self.__class__.__name__

        return self.request_handler(self, **self.get_request_handler_params())
534828
public function handler($handler = null)
    {
        if ($handler !== null) {
            $this->handler = $this->getRealHandler($handler);
        }

        return $this->handler;
    }
446847
public <T> EventHandler<RemoteEvent<T>> getHandler() {
    return new RemoteSenderEventHandler<T>(encoder, transport, executor);
  }
1066900
def get_handler(self, *args, **options):
        
        handler = super(Command, self).get_handler(*args, **options)
        if options['use_livereload']:
            threading.Timer(1, self.livereload_request, kwargs=options).start()
        return handler
1132416
def get_handler(self, *args, **options):
        '''
        
        '''
        handler = super().get_handler(*args, **options)
        use_static_handler = options['use_static_handler']
        insecure_serving = options['insecure_serving']
        if use_static_handler and (settings.DEBUG or insecure_serving):
            return CRAStaticFilesHandler(handler)
        return handler
715900
def get_handler(self, request):
        
        try:
            f = self._json_rpc_methods[request.method]

        except (AttributeError, KeyError):  # pragma no coverage
            raise RPCMethodError("Received invalid method '{}'".format(request.method))

        return f
517651
def get_handler():
    
    host, port, signum = _pdbhandler._registered()
    if signum:
        return Handler(host if host else DFLT_ADDRESS[0].encode(),
                       port if port else DFLT_ADDRESS[1], signum)
420513
def handler(self):
        

        if not hasattr(self, "_handler"):
            self._handler = sys.modules[self.imported]
        return self._handler
208588
public alluxio.grpc.MetaCommand getCommand() {
    alluxio.grpc.MetaCommand result = alluxio.grpc.MetaCommand.valueOf(command_);
    return result == null ? alluxio.grpc.MetaCommand.MetaCommand_Unknown : result;
  }
1067650
public IndirectionHandler getIndirectionHandler(Object obj)
    {
        if(obj == null)
        {
            return null;
        }
        else if(isNormalOjbProxy(obj))
        {
            return getDynamicIndirectionHandler(obj);
        }
        else if(isVirtualOjbProxy(obj))
        {
            return VirtualProxy.getIndirectionHandler((VirtualProxy) obj);
        }
        else
        {
            return null;
        }

    }