/*
(non-Javadoc)

@see com.ibm.ws.sib.ra.inbound.SibRaEndpointStrategy#getMdbMethod()
431336
public Method getEndpointMethod() throws ResourceAdapterInternalException {

        final String methodName = "getEndpointMethod";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        if (ON_MESSAGE_METHOD == null) {

            try {

                ON_MESSAGE_METHOD = SibRaMessageListener.class.getMethod(
                        "onMessage", new Class[] { SIBusMessage.class,
                                AbstractConsumerSession.class,
                                SITransaction.class });

            } catch (final Exception exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_2);
                if (TRACE.isEntryEnabled()) {
                    SibTr.exception(TRACE, exception);
                }
                throw new ResourceAdapterInternalException(NLS
                        .getFormattedMessage("ON_MESSAGE_CWSIV0851",
                                new Object[] { exception }, null), exception);

            }

        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, ON_MESSAGE_METHOD);
        }
        return ON_MESSAGE_METHOD;

    }
884051
public synchronized Xid getXid()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getXid");

      checkReleased();

      int formatId = getInt();
      int glidLength = getInt();
      byte[] globalTransactionId = get(glidLength);
      int blqfLength = getInt();
      byte[] branchQualifier = get(blqfLength);

      XidProxy xidProxy = new XidProxy(formatId, globalTransactionId, branchQualifier);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getXid", xidProxy);
      return xidProxy;
   }
31780
@SuppressWarnings("unchecked")
	public List<Sms> getSms(final Application app, final  int id, final String phoneNumber) {
		DetachedCriteria criteria = DetachedCriteria.forClass(Sms.class);
		criteria.add(Restrictions.eq(Sms.PROP_INITIAL_ID,id));
		criteria.add(Restrictions.eq(Sms.PROP_APP,app));
		criteria.add(Restrictions.eq(Sms.PROP_PHONE, phoneNumber));
		return getHibernateTemplate().findByCriteria(criteria);
	}
1290252
public static AmazonDynamoDB getClient() {
		if (ddbClient != null) {
			return ddbClient;
		}

		if (Config.IN_PRODUCTION) {
			ddbClient = AmazonDynamoDBClientBuilder.standard().build();
		} else {
			ddbClient = AmazonDynamoDBClientBuilder.standard().
					withCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials("local", "null"))).
					withEndpointConfiguration(new EndpointConfiguration(LOCAL_ENDPOINT, "")).build();
		}

		if (!existsTable(Config.getRootAppIdentifier())) {
			createTable(Config.getRootAppIdentifier());
		}

		ddb = new DynamoDB(ddbClient);

		Para.addDestroyListener(new DestroyListener() {
			public void onDestroy() {
				shutdownClient();
			}
		});

		return ddbClient;
	}
739688
public Method getReadMethod() {
        if (readMethod == null) return null;

        try {
            // Note: sun.reflect.ReflectionFactory is not available in Android API
            return readMethod.getDeclaringClass().getDeclaredMethod(readMethod.getName());
        } catch (NoSuchMethodException e) {
            throw new ReflectionException(e.getMessage(), e);// Not Reproducible
        }
    }
577459
protected <T> ManagedObjectFactory<T> getEJBManagedObjectFactory(BeanMetaData bmd, Class<T> klass) throws EJBConfigurationException {
        ManagedObjectFactory<T> factory = null;
        ManagedObjectService managedObjectService = getManagedObjectService();
        if (managedObjectService != null) {
            try {
                factory = managedObjectService.createEJBManagedObjectFactory(bmd._moduleMetaData, klass, bmd.j2eeName.getComponent());
                //TODO the isManaged method could be moved to the ManagedObjectService and then wouldn't need to create the factory
                if (!factory.isManaged()) {
                    factory = null;
                }
            } catch (ManagedObjectException e) {
                throw new EJBConfigurationException(e);
            }
        }

        return factory;
    }
1208515
static BshMethod staticMethodImport(Class<?> baseClass, String methodName) {
        Invocable method = BshClassManager.memberCache.get(baseClass)
                .findStaticMethod(methodName);
        if (null != method)
            return new BshMethod(method, null);
        return null;
    }
936725
private ExtendedManagementProtocol getJMConnection() throws IOException {
		String jmHost = config.getString(ConfigConstants.JOB_MANAGER_IPC_ADDRESS_KEY, null);
		String jmPort = config.getString(ConfigConstants.JOB_MANAGER_IPC_PORT_KEY, null);
		
		return RPC.getProxy(ExtendedManagementProtocol.class,
				new InetSocketAddress(jmHost, Integer.parseInt(jmPort)), NetUtils.getSocketFactory());
	}
1337062
public CmsMacroResolver getMacroResolver() {

        if (m_macroResolver == null) {
            // create a new macro resolver "with everything we got"
            m_macroResolver = CmsMacroResolver.newInstance()
                // initialize resolver with the objects available
                .setCmsObject(m_cms).setMessages(getMessages()).setJspPageContext(
                    (m_jsp == null) ? null : m_jsp.getJspContext());
            m_macroResolver.setParameterMap(m_parameterMap);
        }
        return m_macroResolver;
    }
834786
public JvmOperation getJvmOperation(IMethod method, XtendTypeDeclaration context)
			throws JavaModelException {
		if (!method.isConstructor() && !method.isLambdaMethod() && !method.isMainMethod()) {
			final JvmType type = this.typeReferences.findDeclaredType(
					method.getDeclaringType().getFullyQualifiedName(),
					context);
			return getJvmOperation(method, type);
		}
		return null;
	}
645954
public JvmConstructor getJvmConstructor(IMethod constructor, XtendTypeDeclaration context)
			throws JavaModelException {
		if (constructor.isConstructor()) {
			final JvmType type = this.typeReferences.findDeclaredType(
					constructor.getDeclaringType().getFullyQualifiedName(),
					context);
			if (type instanceof JvmDeclaredType) {
				final JvmDeclaredType declaredType = (JvmDeclaredType) type;
				final ActionParameterTypes jdtSignature = this.actionPrototypeProvider.createParameterTypes(
						Flags.isVarargs(constructor.getFlags()),
						getFormalParameterProvider(constructor));
				for (final JvmConstructor jvmConstructor : declaredType.getDeclaredConstructors()) {
					final ActionParameterTypes jvmSignature = this.actionPrototypeProvider.createParameterTypesFromJvmModel(
							jvmConstructor.isVarArgs(),
							jvmConstructor.getParameters());
					if (jvmSignature.equals(jdtSignature)) {
						return jvmConstructor;
					}
				}
			}
		}
		return null;
	}
597352
@Override
    public ManagedConnectionMetaData getMetaData() throws ResourceException {
        try {
            return new JcrManagedConnectionMetaData(mcf.getRepository(), session);
        } catch (Exception e) {
            throw new ResourceException(e);
        }
    }
505366
public Method getNonProxiedMethod(Class cls, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
		return cls.getMethod(methodName, parameterTypes);
	}
156527
private String extractSQLForJavaDoc(final SQLiteModelMethod method) {
		final One<Boolean> usedInWhere = new One<>(false);
		String sqlForJavaDoc = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {

			@Override
			public String onColumnNameToUpdate(String columnName) {
				return currentEntity.findPropertyByName(columnName).columnName;
			}

			@Override
			public String onColumnName(String columnName) {
				return currentEntity.findPropertyByName(columnName).columnName;
			}

			@Override
			public String onBindParameter(String bindParameterName, boolean inStatement) {
				if (!usedInWhere.value0) {
					if (bindParameterName.contains(".")) {
						String[] a = bindParameterName.split("\\.");

						if (a.length == 2) {
							bindParameterName = a[1];
						}
					}

					return ":" + bindParameterName;
				} else {
					return null;
				}
			}

			@Override
			public void onWhereStatementBegin(Where_stmtContext ctx) {
				usedInWhere.value0 = true;
			}

			@Override
			public void onWhereStatementEnd(Where_stmtContext ctx) {
				usedInWhere.value0 = false;
			};

		});
		return sqlForJavaDoc;
	}
634332
public static Method getDeclaredMethodOfObj(Object obj, String methodName, Object... args) throws SecurityException {
		return getDeclaredMethod(obj.getClass(), methodName, getClasses(args));
	}
1029524
public EntityInstanceWrapper getSelected() throws PMException {
        final EntityContainer container = getEntityContainer(true);
        if (container == null) {
            return null;
        }
        return container.getSelected();
    }
776161
@Override
    public String getMeUuid()
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConnection.tc, "getMeUuid", this);

        // get the meuuid from the messaging engine instead of messageprocessor
        // When ME is stopping connection events are sent to MDB and MDB tries to connect 
        // to ME. Earlier messageprocessor.getmessagingengineuuid() was being called but
        // leads to NPE because messageprocessor.getmessagingengineuuid() gets the uuid from persistent
        // store is stopped(null) by now
        SIBUuid8 meUUID = new SIBUuid8(_messageProcessor.getMessagingEngine().getUuid());

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConnection.tc, "getMeUuid", meUUID);

        return meUUID.toString();
    }