Creates and returns the MethodHandle for reading the underlying ID.

@return the MethodHandle for reading the underlying ID.
332072
private MethodHandle findIdReadMethod() {
    try {
      Method readMethod = clazz.getMethod(READ_METHOD_NAME);
      Class<?> dataClass = readMethod.getReturnType();
      DataType dataType = IdentifierMetadata.DataType.forClass(dataClass);
      if (dataType == null) {
        String pattern = "Method %s in class %s must have a return type of long, Long or String";
        String error = String.format(pattern, READ_METHOD_NAME, clazz.getName());
        throw new EntityManagerException(error);
      }
      return MethodHandles.lookup().unreflect(readMethod);
    } catch (NoSuchMethodException | SecurityException | IllegalAccessException exp) {
      String error = String.format("Class %s must have a public %s method", clazz.getName(),
          READ_METHOD_NAME);
      throw new EntityManagerException(error, exp);
    }
  }
1325058
@Override
    public Handle getHandle() throws RemoteException
    {
        ComponentMetaDataAccessorImpl cmdAccessor = null; // p125735
        try {
            cmdAccessor = ComponentMetaDataAccessorImpl.getComponentMetaDataAccessor(); // p125735
            cmdAccessor.beginContext(bmd); // p125735
            return beanId.getHome().createHandle(beanId);
        } finally
        {
            if (cmdAccessor != null)
                cmdAccessor.endContext(); // p125735
        }
    }
253863
public int getExpandedTypeID(int nodeHandle) {
           nodes.readSlot(nodeHandle, gotslot);
           String qName = m_localNames.indexToString(gotslot[3]);
           // Remove prefix from qName
           // %TBD% jjk This is assuming the elementName is the qName.
           int colonpos = qName.indexOf(":");
           String localName = qName.substring(colonpos+1);
           // Get NS
           String namespace = m_nsNames.indexToString(gotslot[0] << 16);
           // Create expanded name
           String expandedName = namespace + ":" + localName;
           int expandedNameID = m_nsNames.stringToIndex(expandedName);

        return expandedNameID;
        }
1331353
private void defineReadUnionMethod()
    {
        MethodDefinition read = new MethodDefinition(
                a(PUBLIC),
                "read",
                structType,
                arg("protocol", TProtocol.class)
        ).addException(Exception.class);

        // TProtocolReader reader = new TProtocolReader(protocol);
        read.addLocalVariable(type(TProtocolReader.class), "reader");
        read.newObject(TProtocolReader.class);
        read.dup();
        read.loadVariable("protocol");
        read.invokeConstructor(type(TProtocolReader.class), type(TProtocol.class));
        read.storeVariable("reader");

        // field id field.
        read.addInitializedLocalVariable(type(short.class), "fieldId");

        // read all of the data in to local variables
        Map<Short, LocalVariableDefinition> unionData = readSingleFieldValue(read);

        // build the struct
        LocalVariableDefinition result = buildUnion(read, unionData);

        // push instance on stack, and return it
        read.loadVariable(result).retObject();

        classDefinition.addMethod(read);
    }
1353877
public InputHandler getInputHandler()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getInputHandler");
      SibTr.exit(tc, "getInputHandler", inputHandler);
    }
    
    return inputHandler;
  }
1276007
public String getMethodName() {
        if (!visitingMethod) {
            throw new IllegalStateException("getMethodName called while not visiting method");
        }
        if (methodName == null) {
            methodName = getStringFromIndex(method.getNameIndex());
        }

        return methodName;
    }
152994
function defaultClientIDHandler(args, context, info) {
  return get(args, [ 'clientID' ]) ||
    get(context, [ 'clientID' ]) ||
    get(info, [ 'rootValue', 'clientID' ]);
}
1236304
public MethodDocImpl getMethodDoc(MethodSymbol meth) {
        assert !meth.isConstructor() : "not expecting a constructor symbol";
        MethodDocImpl result = (MethodDocImpl)methodMap.get(meth);
        if (result != null) return result;
        result = new MethodDocImpl(this, meth);
        methodMap.put(meth, result);
        return result;
    }
954565
public com.google.protobuf.ByteString
      getHandleBytes() {
    java.lang.Object ref = handle_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      handle_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
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();
   }
158456
public Object getHandle(int iHandleType) throws DBException
    {
        Object bookmark = this.getCurrentTable().getHandle(iHandleType);
        return bookmark;
    }
1213503
function getHandler(method){
    var taxonomy = {
        create: store.set,
        read: store.get,
        update: store.set,
        'delete': store.remove,
        patch: store.set,
        findAll: store.all,
        findById: store.get
      };
    return store[method] || taxonomy[method];
  }
761875
public ProxyPolicyHandler getProxyPolicyHandler(String id) {
    return (id != null && this.proxyPolicyHandlers != null) ?
        (ProxyPolicyHandler)this.proxyPolicyHandlers.get(id) :
        null;
    }
304149
public static <ReqT, RespT> ServerMethodDefinition<ReqT, RespT> create(
      MethodDescriptor<ReqT, RespT> method,
      ServerCallHandler<ReqT, RespT> handler) {
    return new ServerMethodDefinition<>(method, handler);
  }
1253331
public Method getMethod(Method method) {
        return getMethod(method.getReturnType(), method.getName(), method.getParameterTypes());
    }
1016565
public ServletContextHandler getHandler() {
    ServletContextHandler contextHandler = new ServletContextHandler();
    contextHandler.setContextPath(SERVLET_PATH);
    contextHandler.addServlet(new ServletHolder(new MetricsServlet(mCollectorRegistry)), "/");
    return contextHandler;
  }
619421
public Set<Handler> getHandlers() {
        modificationLock.readLock().lock();
        try {
            return new HashSet<>(handlers);
        } finally {
            modificationLock.readLock().unlock();
        }
    }