Note in the database that a particular transition has been applied.

@return true if the transition was noted, false if it could not be noted because another
process noted it first.
513220
public boolean noteTransition (Class<?> clazz, final String name)
        throws PersistenceException
    {
        final String cname = clazz.getName();
        return executeUpdate(new Operation<Boolean>() {
            public Boolean invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                PreparedStatement stmt = null;
                try {
                    stmt = conn.prepareStatement(
                        "insert into " + liaison.tableSQL("TRANSITIONS") + " (" +
                        liaison.columnSQL("CLASS") + ", " + liaison.columnSQL("NAME") +
                        ", " + liaison.columnSQL("APPLIED") +
                        ") values (?, ?, ?)");
                    stmt.setString(1, cname);
                    stmt.setString(2, name);
                    stmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
                    JDBCUtil.checkedUpdate(stmt, 1);
                    return true;

                } catch (SQLException sqe) {
                    if (liaison.isDuplicateRowException(sqe)) {
                        return false;
                    } else {
                        throw sqe;
                    }

                } finally {
                    JDBCUtil.close(stmt);
                }
            }
        });
    }
1352044
private static boolean isRunningInWAS() {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "isRunningInWAS");
        }

        if (inWAS == null) {
            inWAS = Boolean.TRUE;
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "isRunningInWAS", inWAS);
        }
        return inWAS.booleanValue();
    }
249148
public function hasChanged()
    {
        foreach ($this->modelData as $property => $value) {
            if ($this->hasPropertyChanged($property)) {
                return true;
            }
        }

        // In case model data has been manually unset
        $manuallyUnsetProperties = array_diff_key($this->changeSnapshotData, $this->modelData);
        foreach ($manuallyUnsetProperties as $property => $value) {
            // If it wasn't null before, that's a change
            if ($value !== null) {
                return true;
            }
        }

        return false;
    }
951201
public boolean onDelete()
    {
        Record record = this.getMainRecord();
        if (record == null)
            return false;

        if (record.getEditMode() == Constants.EDIT_NONE)
            return true;
        if (record.getEditMode() == Constants.EDIT_ADD)
        {   // If they're adding, can't delete nothing!
            this.onRefresh();
            return true;
        }
        try {
            if (record.getEditMode() != Constants.EDIT_IN_PROGRESS)
                record.edit();
            record.remove();
            record.addNew();
            this.clearStatusText();
        } catch(DBException ex) {
            this.displayError(ex);
            return false;
        }
        return true;
    }
1152791
public boolean recordStableIdGenerator() {
    if (!currentInfo.isStableIdGenerator()) {
      currentInfo.setStableIdGenerator(true);
      populated = true;
      return true;
    } else {
      return false;
    }
  }
513403
public boolean isPersistent()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
    {
      SibTr.entry(this, tc, "isPersistent");
      SibTr.exit(tc, "isPersistent", Boolean.valueOf(persistent));	
    }
    return persistent;
  }
207805
boolean transitionToStickyGlobalTran(BeanId beanId,
                                         ContainerTx currentTx,
                                         ContainerTx expectedTx) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "transitionToStickyGlobalTran (" + beanId +
                         "," + currentTx + ", " + expectedTx + ")");

        ContainerTx resumedTx = null;
        EJSDeployedSupport s = getMethodContext();
        EJBMethodInfoImpl methodInfo = s.methodInfo;
        BeanMetaData bmd = beanId.getBeanMetaData();

        try {
            // -----------------------------------------------------------------------
            // First, complete the local transaction that was started early in
            // preInvoke with the normal postInvoke processing.
            // -----------------------------------------------------------------------
            currentTx.postInvoke(s);
            uowCtrl.postInvoke(beanId, s.uowCookie, s.exType, methodInfo);

            // Clear to insure postInvoke we occur again if there are failures below.
            s.uowCtrlPreInvoked = false;
            s.currentTx = null;

            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "transitionToStickyGlobalTran : local tx completed");

            // -----------------------------------------------------------------------
            // Next, resume the sticky global transaction by executing the same
            // code that would normally happen early in preInvoke.
            // -----------------------------------------------------------------------

            s.uowCookie = uowCtrl.preInvoke(beanId, methodInfo);
            s.uowCtrlPreInvoked = true;

            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "transitionToStickyGlobalTran : sticky global resumed");

            // Get the Container Transaction object (ContainerTx) associated
            // with the current transaction, as returned in the UOW Cookie
            // on UOW preInvoke.
            boolean isLocal = s.uowCookie.isLocalTx();
            SynchronizationRegistryUOWScope UOWid = s.uowCookie.getTransactionalUOW();
            resumedTx = getCurrentTx(UOWid, isLocal);

            s.currentTx = resumedTx;
            resumedTx.preInvoke(s);

            // -----------------------------------------------------------------------
            // Now complete the rest of the transaction processing that normally
            // occurs in preInvoke.
            // -----------------------------------------------------------------------

            int isolationLevel = methodInfo.isolationAttr;
            if (bmd.ivModuleVersion <= BeanMetaData.J2EE_EJB_VERSION_1_1 ||
                (bmd.ivModuleVersion >= BeanMetaData.J2EE_EJB_VERSION_2_0 &&
                 bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X)) {
                resumedTx.setIsolationLevel(isolationLevel);
            }
            s.currentIsolationLevel = isolationLevel;
        } catch (RemoteException rex) {
            FFDCFilter.processException(rex, CLASS_NAME + ".getBean", "1542", this);

            // Something very unexpected, and ugly happened. Report this as an
            // EJBException, which will cause bean activation to fail. The method
            // context should be in an appropriate state that postInvoke will be
            // able to cleanup properly.
            throw ExceptionUtil.EJBException("A failure occured resuming a bean managed transaction", rex);
        }

        // -----------------------------------------------------------------------
        // Return true only if expected 'sticky' transaction was indeed resumed.
        // It is possible that a different thread resumed the sticky transaction
        // first, so this thread will still just have a local transaction and
        // should continue to wait to lock the bean; false is returned.  d671368.1
        // -----------------------------------------------------------------------

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "transitionToStickyGlobalTran : " + (resumedTx == expectedTx));

        return resumedTx == expectedTx;
    }
610287
protected boolean doStart()
  {
    if (! _lifecycle.isActive()) {
      return false;
    }
    
    if (! isEnable()) {
      return false;
    }
    
    int startingCount = _startingCount.getAndIncrement();

    int threadCount = _threadCount.get() + startingCount;

    if (_threadMax < threadCount) {
      _startingCount.decrementAndGet();
      
      onThreadMax();
      
      return false;
    }
    else if (isIdleTooLow(startingCount)) {
      return true;
    }
    else {
      _startingCount.decrementAndGet();
      
      return false;
    }
  }
1298605
public boolean isEnlisted() {

        final String methodName = "isEnlisted";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        final boolean enlisted = _siXaResource.isEnlisted();

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, Boolean.valueOf(enlisted));
        }
        return enlisted;

    }
638014
public static boolean callbacksRegistered() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "callbacksRegistered");

        if (_syncLevel < 0) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                Tr.exit(tc, "callbacksRegistered", Boolean.FALSE);
            return false;
        }

        final int maxLevels = _syncLevels.size();
        for (int level = 0; level < maxLevels; level++) {
            final ArrayList syncs = _syncLevels.get(_syncLevel);

            if (syncs != null && !syncs.isEmpty()) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    Tr.exit(tc, "callbacksRegistered", Boolean.TRUE);
                return true;
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "callbacksRegistered", Boolean.FALSE);
        return false;
    }
987916
public function isChanged()
    {
        // When unbound, use the local changed flag
        if (! ($this->record instanceof DataObject)) {
            return $this->isChanged;
        }

        // Defer to parent record
        foreach ($this->compositeDatabaseFields() as $field => $spec) {
            $key = $this->getName() . $field;
            if ($this->record->isChanged($key)) {
                return true;
            }
        }
        return false;
    }
1243800
public boolean processThisRecord(Record record)
    {
        if (record != null)
        {   // Delete all the records
            this.disableAllListeners(record);
            if ((record.getDatabaseType() & (DBConstants.BASE_TABLE_CLASS | DBConstants.SHARED_TABLE)) == (DBConstants.BASE_TABLE_CLASS | DBConstants.SHARED_TABLE))
                this.initSharedRecord(record);
            record.close();
            try {
                while (record.hasNext())
                {
                    record.next();
                    record.edit();
                    record.remove();
                }
            } catch (DBException e) {
                e.printStackTrace();
            }
        }
        return true;
    }
736194
protected boolean atStart()
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass
                        , "atStart"
                            );

        boolean atStartOfLogRecord = (bufferCursor == 0) && (bufferByteCursor == 0);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass
                       , "atStart"
                       , "returns atStartOfLogRecord=" + atStartOfLogRecord + "(boolean)"
                            );
        return atStartOfLogRecord;
    }
155772
public boolean hasChanges() {
        for (Map.Entry<Object, DocumentInfo> entity : documentsByEntity.entrySet()) {
            ObjectNode document = entityToJson.convertEntityToJson(entity.getKey(), entity.getValue());
            if (entityChanged(document, entity.getValue(), null)) {
                return true;
            }
        }

        return !deletedEntities.isEmpty();
    }
608754
public final boolean isAutoCommit()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isAutoCommit");
            SibTr.exit(this, tc, "isAutoCommit", "return=false");
        }
        return false;
    }
158977
public boolean isForeignKeyChanged() {
        return CollectionUtils.exists(differences.values(), new Predicate() {
            @Override
            public boolean evaluate(Object object) {
                return ((ModelDiffEntry) object).isForeignKey();
            }
        });
    }
1311172
public boolean isDeleted()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "isDeleted");
      SibTr.exit(tc, "isDeleted", new Boolean(isDeleted));
    }
    return isDeleted;
  }