Create a Handle for the given BeanId
496262
@Override
    public final Handle createHandle(BeanId id)
                    throws RemoteException
    {
        EJSWrapper wrapper = null;
        homeEnabled();

        wrapper = getWrapper(id).getRemoteWrapper(); // f111627; //p116577

        if (!statelessSessionHome && !statefulSessionHome)
        {
            if (cvUsePortableClass) //p125891
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "createHandle():Creating portable HandleImpl"); //p125891

                // p116577 - start of change
                // Need to make EntityHandle class use only
                // SUN JDK or Java EE interfaces.  So, we need to pass EJBObject
                // stub to the EntityHandle constructor.
                return new HandleImpl((EJBObject) PortableRemoteObject.toStub(wrapper)); // F743-509.CodRev
                // p116577 - end of change
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "createHandle():Creating non-portable EntityHandle"); //p125891
                Properties pFake = null;
                return new EntityHandle(id, beanMetaData, pFake); //p125891 //d145386
            }
        }
        else
        {
            Object wrapperRef = container.getEJBRuntime().getRemoteReference(wrapper);
            EJBObject object = (EJBObject) PortableRemoteObject.narrow(wrapperRef, EJBObject.class);
            return container.sessionHandleFactory.create(object);
        }
    }
142149
def create(handler, item_document):
    """"""
    data = {'operation': 'create',
            'item': json.load(item_document)}
    handler.invoke(data)
1224969
public static RuntimeException handle(Throwable e) {
        if (e instanceof CRestException) {
            return handle((CRestException) e);
        }else if (e instanceof RequestException) {
            return handle((RequestException) e);
        } else if (e instanceof IllegalArgumentException) {
            return handle((IllegalArgumentException) e);
        } else if (e instanceof IllegalStateException) {
            return handle((IllegalStateException) e);
        } else if (e instanceof InvocationTargetException) {
            return handle((InvocationTargetException) e);
        } else {
            return new CRestException(e.getMessage(), e);
        }
    }
1031890
@Process(actionType = CreateHandler.class)
    public void createHandler(final CreateHandler action, final Dispatcher.Channel channel) {
        operationDelegate.onCreateResource(action.getAddressTemplate(), action.getInstanceName(), action.getNewModel(),
            new CrudOperationDelegate.Callback() {
                @Override
                public void onFailure(AddressTemplate template, String name, Throwable t) {
                    channel.nack(t);
                }

                @Override
                public void onSuccess(AddressTemplate addressTemplate, String name) {
                    lastModifiedInstance = action.getInstanceName();
                    // we must strip the pre-handler-chain suffix to reload a single configuration. 
                    readConfig(action.getAddressTemplate().subTemplate(0, 3), channel);
                }
            });
    }
4185
@Override
  public Response handle() throws Exception {
    StatusGenerator gen = new StatusGenerator(getServer());


    JSONObject res = gen.generate();

    List<ServerSideSession> sessions = getServer().getSessions();
    Response resp = new Response();

    resp.setStatus(0);
    resp.setValue(res);
    if (sessions.size() == 0) {
      resp.setSessionId(null);
    } else if (sessions.size() == 1) {
      resp.setSessionId(sessions.get(0).getSessionId());
    } else {
      throw new WebDriverException("NI multi sessions per server.");
    }
    return resp;
  }
12075
@SuppressWarnings("unchecked")
  private void handleRequest(long requestId, Object request) {
    HandlerHolder holder = handlers.get(request.getClass());
    if (holder == null) {
      connection.handleResponseError(requestId, new ConnectException("no handler registered"));
      return;
    }

    Function<Object, CompletableFuture<Object>> handler = (Function<Object, CompletableFuture<Object>>) holder.handler;

    try {
      holder.context.executor().execute(() -> {
        if (open && connection.open) {
          CompletableFuture<Object> responseFuture = handler.apply(request);
          if (responseFuture != null) {
            responseFuture.whenComplete((response, error) -> {
              if (!open || !connection.open) {
                connection.handleResponseError(requestId, new ConnectException("connection closed"));
              } else if (error == null) {
                connection.handleResponseOk(requestId, response);
              } else {
                connection.handleResponseError(requestId, error);
              }
            });
          }
        } else {
          connection.handleResponseError(requestId, new ConnectException("connection closed"));
        }
      });
    } catch (RejectedExecutionException e) {
      connection.handleResponseError(requestId, new ConnectException("connection closed"));
    }
  }
865692
def write_handle(self, handle: int, value: bytes):
        """"""
        if not self.is_connected():
            raise BluetoothBackendException('Not connected to device!')
        self._device.char_write_handle(handle, value, True)
        return True
612560
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if( bean instanceof AuthenticationAware || bean instanceof LoginAware ) {

            // If the bean isn't a singleton, then add it to our list
            if( beanName == null || !getApplicationContext().containsBean( beanName )
                    || !getApplicationContext().isSingleton( beanName ) ) {
                addToNonSingletonListeners( bean );
            }

            // Install the last known authentication token
            if( bean instanceof AuthenticationAware ) {
                if( logger.isDebugEnabled() )
                    logger.debug( "NOTIFY bean '" + bean + "' of new authorization for '" + currentAuthentication
                            + "'" );

                AuthenticationAware aab = (AuthenticationAware) bean;
                aab.setAuthenticationToken(currentAuthentication);
            }
        }
        return bean;
    }
1317035
function (widgetName, beanDef) {
            if (widgetName == "Icon") {
                // no inheritance, use usual normalization
                return function (skinClassName, skin, std) {
                    beanDef.$fastNorm(skin);
                };
            }
            var hasFrame = (beanDef.$properties.frame != null);
            var writer = new ariaUtilsFunctionWriter(["skinClassName", "skin", "std"]);
            ariaUtilsInheritanceNormalization.writeInheritanceNormalization({
                writer : writer,
                beanDef : beanDef,
                varToNormalize : "skin",
                parentVars : ["std"],
                excludes : {
                    "states" : true,
                    "frame" : true
                }
            });
            if (hasFrame) {
                // uses a frame, let's normalize it
                var frameStateNormalizerVar = writer.createTempVariable("this.normFrame(this.widgetName,skinClassName,skin,std)");
            }
            var states = beanDef.$properties.states;
            if (states) {
                states = states.$properties;
                writer.writeEnsureObjectExists("skin.states");
                var skinStatesVar = writer.createTempVariable("skin.states");
                var stdStatesVar = writer.createTempVariable("std.states||{}");
                var out = writer.out;
                for (var curState in states) {
                    if (states.hasOwnProperty(curState) && curState != "normal") {
                        var dotState = writer.getDotProperty(curState);
                        writer.writeEnsureObjectExists(skinStatesVar + dotState);
                        out.push("this.normState(", skinStatesVar, dotState, ",", stdStatesVar, dotState, ",", skinStatesVar, ".normal,", stdStatesVar, ".normal);");
                        if (hasFrame) {
                            // uses a frame, let's normalize it
                            out.push(frameStateNormalizerVar, ".call(this,skinClassName,", writer.stringify(curState), ",", skinStatesVar, dotState, ",", stdStatesVar, dotState, ",", skinStatesVar, ".normal, ", stdStatesVar, ".normal);");
                        }
                    }
                }
                writer.writeEnsureObjectExists(skinStatesVar + ".normal");
                out.push("this.normState(", skinStatesVar, ".normal, ", stdStatesVar, ".normal);");
                if (hasFrame) {
                    // uses a frame, let's normalize it
                    out.push(frameStateNormalizerVar, '.call(this,skinClassName,"normal",', skinStatesVar, '.normal,', stdStatesVar, '.normal);');
                }

            }
            var res = writer.createFunction();
            writer.$dispose();
            return res;
        }
803634
function initPostOne(router, adminCGIBase, pluginName, handlerNameField, callback) {
    router.post(`${adminCGIBase}/${pluginName}/:${handlerNameField}`, callback);
}
401623
protected function createHandle(){

		if(!empty($this->stack)){
			$url = array_shift($this->stack);

			if($url instanceof URL){
				$curl = curl_init($url->mergeParams());

				curl_setopt_array($curl, $this->curl_options);
				curl_multi_add_handle($this->curl_multi, $curl);

				if($this->options->sleep){
					usleep($this->options->sleep);
				}

			}
			else{
				// retry on next if we don't get what we expect
				$this->createHandle(); // @codeCoverageIgnore
			}

		}

	}
76879
function genWeexHandler (params, handlerCode) {
  var innerHandlerCode = handlerCode;
  var exps = params.filter(function (exp) { return simplePathRE.test(exp) && exp !== '$event'; });
  var bindings = exps.map(function (exp) { return ({ '@binding': exp }); });
  var args = exps.map(function (exp, i) {
    var key = "$_" + (i + 1);
    innerHandlerCode = innerHandlerCode.replace(exp, key);
    return key
  });
  args.push('$event');
  return '{\n' +
    "handler:function(" + (args.join(',')) + "){" + innerHandlerCode + "},\n" +
    "params:" + (JSON.stringify(bindings)) + "\n" +
    '}'
}
1156895
@SuppressWarnings({ "rawtypes" })
   public <T> T executeForBean(int sqlId, Map<String, ? extends Object> bindParams, Class bean) {
      String sql = context.getResources().getString(sqlId);
      return executeForBean(sql, bindParams, bean);
   }
277287
@Override
    public void handle() throws HandlerException {
        String repository = getAuditEvent().getRepository();
        boolean writeInDefaultTable = !separate || repository == null;
        String tableName = writeInDefaultTable ? default_table_name : generateTableName(repository);

        getDaoForTable(tableName).writeEvent(getAuditEvent());
    }
855285
public final BeanO create(EJSContainer c, EJSHome h, boolean reactivate) // d623673.1
    throws RemoteException, InvocationTargetException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "create: " + h);

        BeanO beanO = newInstance(c, h);
        boolean success = false;

        try
        {
            beanO.initialize(reactivate);
            success = true;
        } finally
        {
            if (!success)
            {
                beanO.discard();
            }

            if (isTraceOn && tc.isEntryEnabled())
                Tr.exit(tc, "create: " + beanO + ", success=" + success);
        }

        return beanO;
    }
72786
public void handle() {
        try {
            for (handleIndex++; handleIndex < handlers.size(); handleIndex++) {
                handlers.get(handleIndex).handle(this);
            }
        } catch (final Exception e) {
            final String requestLog = Requests.getLog(request);
            LOGGER.log(Level.ERROR, "Handler process failed: " + requestLog, e);

            setRenderer(new Http500Renderer(e));
        }
    }
593598
public BaseRequestHandler loadHandler(String handlerClassName, String uri)
      throws
      ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
      InvocationTargetException, InstantiationException {
    Class<? extends BaseRequestHandler> handlerClass =
        classLoader.loadClass(handlerClassName).asSubclass(BaseRequestHandler.class);
    Constructor<? extends BaseRequestHandler> constructor =
        handlerClass.getConstructor(String.class);
    return constructor.newInstance(uri);
  }