/* (non-Javadoc)
@see com.ibm.ws.sib.mfp.control.ControlCreateDurable#isCloned()
499272
public final boolean isCloned() {
    boolean result = false;
    // if the value is unset then it has come from an environment with back level schema
    if (jmo.getChoiceField(ControlAccess.BODY_CREATEDURABLE_CLONED) != ControlAccess.IS_BODY_CREATEDURABLE_CLONED_UNSET) {
      result = jmo.getBooleanField(ControlAccess.BODY_CREATEDURABLE_CLONED_VALUE);
    }
    return result;
  }
586409
public static <T> boolean isSuccessful(CompletableFuture<T> f) {
        return f.isDone() && !f.isCompletedExceptionally() && !f.isCancelled();
    }
1150559
public static boolean isClonedServer() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isClonedServer");

        // If we have not yet found out this information.
        if (isCloned == null) {
            isCloned = Boolean.valueOf(RuntimeInfo.isClusteredServer());
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isClonedServer", isCloned);
        return isCloned.booleanValue();
    }
772794
@SuppressWarnings("unchecked")
    public static boolean isRunnable(Class cl, String methodName, List<FilterDefinition> filters) {
        try {
            Method method = cl.getMethod(methodName);

            return isRunnable(cl, method, filters);
        } catch (NoSuchMethodException | SecurityException e) {
            return true;
        }
    }
233899
public boolean isEnlisted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isEnlisted");

        boolean retval = false;

        if (_currentTran != null)
        {
            retval = true;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isEnlisted", "return="+retval);
        return retval;
    }
205587
@SuppressWarnings("unchecked")
    public static boolean isRunnable(Class cl, Method method, List<FilterDefinition> filters) {
        // Get the ROX annotations
        ProbeTest mAnnotation = method.getAnnotation(ProbeTest.class);
        ProbeTestClass cAnnotation = method.getDeclaringClass().getAnnotation(ProbeTestClass.class);

        String fingerprint = FingerprintGenerator.fingerprint(cl, method);

        if (mAnnotation != null || cAnnotation != null) {
            return isRunnable(new FilterTargetData(fingerprint, method, mAnnotation, cAnnotation), filters);
        } else {
            return isRunnable(new FilterTargetData(fingerprint, method), filters);
        }
    }
98056
@SuppressWarnings("unchecked")
	public static boolean isRunnable(Class cl, String methodName, String[] filters) {
		try {
			Method m = cl.getMethod(methodName);
			return isRunnable(m, filters);
		}
		catch (NoSuchMethodException | SecurityException e) {
			return true;
		}
	}
988367
@Override
    public boolean isToBeDeleted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isToBeDeleted", new Object[] { getName() });

        boolean toBeDeleted = _targetDestinationHandler.isToBeDeleted();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isToBeDeleted", Boolean.valueOf(toBeDeleted));

        return toBeDeleted;
    }
212554
public boolean isRunning() {
    lock.lock();
    try {
      return process != null && process.isRunning();
    } catch (IllegalThreadStateException e) {
      return true;
    } finally {
      lock.unlock();
    }
  }
620621
@Override
    public boolean isRemoved() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "isRemoved : false");
        return false;
    }
254591
public synchronized boolean isRunning() {
        if (null == process) return false;

        try {
            process.exitValue();
            return false;
        } catch(IllegalThreadStateException itse) {
            return true;
        }
    }
559036
public static void setIsClonedServer(Boolean newVal) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setIsClonedServer", newVal);
        isCloned = newVal;
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setIsClonedServer");
    }
964927
public boolean resumeWaiting(InternalEvent eventMessageDoc) throws ActivityException {
        EventWaitInstance received = registerWaitEvents(true, true);
        if (received!=null) {
            setReturnCodeAndExitStatus(received.getCompletionCode());
            processMessage(getExternalEventInstanceDetails(received.getMessageDocumentId()));
            return handleCompletionCode();
        } else return false;
    }
574562
public boolean isDelivered()
  {
    if (tc.isEntryEnabled()) 
      SibTr.entry(tc, "isDelivered");
      
    boolean delivered = aiValueTick.isDelivered();
    
    if (tc.isEntryEnabled()) 
      SibTr.exit(tc, "isDelivered", Boolean.valueOf(delivered));
    return delivered;
  }
506791
private synchronized final boolean _declareDiscardable()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "_declareDiscardable");

        boolean linkHasBecomeReleasable = false;
        // Only discardable if storage managed (items and item references only).
        // Putting this check in here liberates the logic which changes the state of the
        // items from knowing about storage management
        if (_isStorageManaged)
        {
            if (!_itemIsDiscardableIfPersistentRepresentationStable)
            {
                // if we have become non-discardable, and we were
                // releasable (stable) then we must notify the cache
                linkHasBecomeReleasable = _persistentRepresentationIsStable;
                // 274012
                if (linkHasBecomeReleasable)
                {
                    // Defect 601995
                    _strongReferenceToItem = NULL_STRONG_REF;
                }

                // This flag must not be set if the item is not storage managed.
                // Otherwise, we could inadvertently start discarding and restoring
                // streams.
                _itemIsDiscardableIfPersistentRepresentationStable = true;
            }
        }
        else
        {
            // Just to make sure :-)
            _itemIsDiscardableIfPersistentRepresentationStable = false;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "_declareDiscardable", Boolean.valueOf(linkHasBecomeReleasable));
        return linkHasBecomeReleasable;
    }
1290910
@Override
    public boolean isTransacted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isTransacted");
            SibTr.exit(this, tc, "isTransacted", Boolean.valueOf(transacted));
        }
        return transacted;
    }
20075
public boolean isClosed()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "isClosed", this);
            SibTr.exit(tc, "isClosed", Boolean.valueOf(_closed));
        }
        return _closed;
    }