Determines whether or not an activation spec is RRS transactional.

@param activationSpec activation spec
@return true if the activation spec is RRS transactional. False if not.
356897
@FFDCIgnore(NoSuchMethodException.class)
    private static boolean isRRSTransactional(Object activationSpec) {
        try {
            return (Boolean) activationSpec.getClass().getMethod("getRRSTransactional").invoke(activationSpec);
        } catch (NoSuchMethodException x) {
            return false;
        } catch (Exception x) {
            return false;
        }
    }
118469
public boolean isCommitted() {
		Transaction tx = getTransaction();
		// Issue 1571 : http://code.google.com/p/mobicents/issues/detail?id=1571 
		// NullPointerException in SipServletResponseImpl.isCommitted
		if(tx != null) {
			//the message is an incoming non-reliable provisional response received by a servlet acting as a UAC
			if(tx instanceof ClientTransaction && getStatus() >= 101 && getStatus() <= 199 && getHeader("RSeq") == null) {
				if(this.proxyBranch == null) { // Make sure this is not a proxy. Proxies are allowed to modify headers.
					return true;
				} else {
					return false;
				}
			}
			//the message is an incoming reliable provisional response for which PRACK has already been generated. (Note that this scenario applies to containers that support the 100rel extension.)
			if(tx instanceof ClientTransaction && getStatus() >= 101 && getStatus() <= 199 && getHeader("RSeq") != null && TransactionState.TERMINATED.equals(tx.getState())) {
				if(this.proxyBranch == null) { // Make sure this is not a proxy. Proxies are allowed to modify headers.
					return true;
				} else {
					return false;
				}
			}
			//the message is an incoming final response received by a servlet acting as a UAC for a Non INVITE transaction
			if(tx instanceof ClientTransaction && getStatus() >= 200 && getStatus() <= 999 && !Request.INVITE.equals(((SIPClientTransaction)tx).getMethod())) {
				if(this.proxyBranch == null) { // Make sure this is not a proxy. Proxies are allowed to modify headers.
					return true;
				} else {
					return false;
				}
			}
			//the message is a response which has been forwarded upstream
			if(isResponseForwardedUpstream) {
				return true;
			}
			//message is an incoming final response to an INVITE transaction and an ACK has been generated
			if(tx instanceof ClientTransaction && getStatus() >= 200 && getStatus() <= 999 && TransactionState.TERMINATED.equals(tx.getState()) && isAckGenerated) {
				return true;
			}
		}
		return false;
	}
120406
@Override
    public boolean isTransactionActive() {

        if (this.getTransactionManager() != null)
            try {
                if (this.getTransactionManager().getStatus() == Status.STATUS_ACTIVE)
                    return true;

            } catch (SystemException se) {
                if (TC.isDebugEnabled()) {
                    Tr.debug(TC, "Returning isTransactionActive() false: " + se.getMessage());
                }
                return false;
            }
        return false;
    }
488508
public int
verify(RRset set, Cache cache) {
	Iterator sigs = set.sigs();
	if (Options.check("verbosesec"))
		System.out.print("Verifying " + set.getName() + "/" +
				 Type.string(set.getType()) + ": ");
	if (!sigs.hasNext()) {
		if (Options.check("verbosesec"))
			System.out.println("Insecure");
		return DNSSEC.Insecure;
	}
	while (sigs.hasNext()) {
		RRSIGRecord sigrec = (RRSIGRecord) sigs.next();
		if (verifySIG(set, sigrec, cache) == DNSSEC.Secure) {
			if (Options.check("verbosesec"))
				System.out.println("Secure");
			return DNSSEC.Secure;
		}
	}
	if (Options.check("verbosesec"))
		System.out.println("Failed");
	return DNSSEC.Failed;
}
10394
public static boolean isSelfSigned(X509Certificate cert,
        String sigProvider) {
        if (isSelfIssued(cert)) {
            try {
                if (sigProvider == null) {
                    cert.verify(cert.getPublicKey());
                } else {
                    cert.verify(cert.getPublicKey(), sigProvider);
                }
                return true;
            } catch (Exception e) {
                // In case of exception, return false
            }
        }
        return false;
    }
678573
public static int cudnnGetActivationDescriptor(
        cudnnActivationDescriptor activationDesc, 
        int[] mode, 
        int[] reluNanOpt, 
        double[] coef)/**  */
    {
        return checkResult(cudnnGetActivationDescriptorNative(activationDesc, mode, reluNanOpt, coef));
    }
809576
public static boolean isCommittedProcessed(byte[] stateBytes, Transaction tx) {
    long writePointer = Bytes.toLong(stateBytes, 0, Longs.BYTES);
    if (!tx.isVisible(writePointer)) {
      return false;
    }
    byte state = stateBytes[Longs.BYTES + Ints.BYTES];
    return state == ConsumerEntryState.PROCESSED.getState();
  }
1206392
public boolean isProducerQOSOverrideEnabled()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "isProducerQOSOverrideEnabled");    
    boolean allowed = aliasDest.isOverrideOfQOSByProducerAllowed();    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "isProducerQOSOverrideEnabled", new Boolean(allowed));   
    return allowed;
  }
793934
public static boolean verifyTimestampCertificates(TimeStampToken ts, KeyStore keystore, String provider) {
        if (provider == null)
            provider = "BC";
        try {
            for (Enumeration aliases = keystore.aliases(); aliases.hasMoreElements();) {
                try {
                    String alias = (String)aliases.nextElement();
                    if (!keystore.isCertificateEntry(alias))
                        continue;
                    X509Certificate certStoreX509 = (X509Certificate)keystore.getCertificate(alias);
                    SignerInformationVerifier siv = new JcaSimpleSignerInfoVerifierBuilder().setProvider(provider).build(certStoreX509);
                    ts.validate(siv);
                    return true;
                }
                catch (Exception ex) {
                }
            }
        }
        catch (Exception e) {
        }
        return false;
    }
609927
private boolean validateServiceIntent(Context context, Intent intent) {
        ResolveInfo resolveInfo = context.getPackageManager().resolveService(intent, 0);
        if (resolveInfo == null) {
            return false;
        }

        return validateAppSignatureForPackage(context, resolveInfo.serviceInfo.packageName);
    }
382258
public synchronized boolean isEventBeingProcessed(UUID chainIdentifier) {
        ArrayList<UUID> eventIdentifiers = chainTracker.get(chainIdentifier);
        return eventIdentifiers != null && eventIdentifiers.size() != 0;
    }
277151
public void endpointDeactivation(MessageEndpointFactory endpointFactory,
      ActivationSpec spec) {
    VertxActivation activation = activations.remove(spec);
    if (activation != null)
      activation.stop();

    log.finest("endpointDeactivation()");

  }
376297
protected boolean evaluateManualActivationRule(CmmnActivityExecution execution) {
    boolean manualActivation = false;
    CmmnActivity activity = execution.getActivity();
    Object manualActivationRule = activity.getProperty(PROPERTY_MANUAL_ACTIVATION_RULE);
    if (manualActivationRule != null) {
      CaseControlRule rule = (CaseControlRule) manualActivationRule;
      manualActivation = rule.evaluate(execution);
    }
    return manualActivation;
  }
508053
private void activateEndpointInternal(MessageEndpointFactoryImpl mef, boolean explicit) throws ResourceException {
        // Wait for the destination if specified by the MDB.  If it is instead
        // specified on the activationSpec, then the EndpointActivationService
        // won't be registered until the destination is available, so we
        // implicitly wait for the destination anyway.  If the destination isn't
        // specified at all, then the activation will fail.

        if (mef.adminObjectServiceInfo != null && mef.adminObjectServiceInfo.serviceRef == null) {
            if (explicit) {
                Tr.warning(tc, "MDB_DESTINATION_NOT_FOUND_CNTR4016W", mef.getJ2EEName().getComponent(), mef.adminObjectServiceInfo.id);
            }
            return;
        }

        if (mef.schemeJndiNameInfo != null && !mef.schemeJndiNameInfo.lookupSucceeded()) {
            if (explicit) {
                Tr.warning(tc, "MDB_DESTINATION_NOT_FOUND_CNTR4016W", mef.getJ2EEName().getComponent(), mef.schemeJndiNameInfo.getJndiName());
            }
        }

        EndpointActivationService eas = mef.endpointActivationServiceInfo.getService();
        if (eas == null) {
            if (explicit) {
                Tr.warning(tc, "MDB_ACTIVATION_SPEC_NOT_FOUND_CNTR4015W", mef.getJ2EEName().getComponent(), mef.endpointActivationServiceInfo.id);
            }
            return;
        }

        if (!isServerStarted) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "server is not started");
            }
            return;
        }

        mef.activateEndpointInternal(eas,
                                     mef.endpointActivationServiceInfo.getMaxEndpoints(),
                                     mef.adminObjectServiceInfo == null ? null :
                                                     (AdminObjectService) context.locateService("adminObjectServices", mef.adminObjectServiceInfo.serviceRef)
                        );
        mef.runtimeActivated = true;
    }
988849
@SuppressWarnings("checkstyle:npathcomplexity")
	public boolean selectSpecificSRE(ISREInstall sre) {
		ISREInstall theSRE = sre;
		if (theSRE == null) {
			theSRE = SARLRuntime.getDefaultSREInstall();
		}
		if (theSRE != null) {
			boolean changed = false;
			final boolean oldNotify = this.notify;
			try {
				this.notify = false;
				if (isSystemWideDefaultSRE()) {
					doSpecificSREButtonClick();
					changed = true;
				}
				final ISREInstall oldSRE = getSelectedSRE();
				if (oldSRE != theSRE) {
					final int index = indexOf(theSRE);
					if (index >= 0) {
						this.runtimeEnvironmentCombo.select(index);
						changed = true;
					}
				}
				if (!this.runtimeEnvironments.isEmpty()) {
					int selection = this.runtimeEnvironmentCombo.getSelectionIndex();
					if (selection < 0 || selection >= this.runtimeEnvironments.size()) {
						// Ensure that there is a selected element
						selection = indexOf(theSRE);
						this.runtimeEnvironmentCombo.select((selection < 0) ? 0 : selection);
						changed = true;
					}
				}
			} finally {
				this.notify = oldNotify;
			}
			if (changed) {
				firePropertyChange();
				return true;
			}
		}
		return false;
	}
65373
public boolean isEnabledSaslMechanism(String saslMechanism) {
        // If enabledSaslMechanisms is not set, then all mechanisms which are not blacklisted are enabled per default.
        if (enabledSaslMechanisms == null) {
            return !SASLAuthentication.getBlacklistedSASLMechanisms().contains(saslMechanism);
        }
        return enabledSaslMechanisms.contains(saslMechanism);
    }
519068
public static boolean isPlatformSRE(ISREInstall sre) {
		if (sre != null) {
			LOCK.lock();
			try {
				return platformSREInstalls.contains(sre.getId());
			} finally {
				LOCK.unlock();
			}
		}
		return false;
	}