The state has changed so that the item could be discarded if it has
a stable persistent representation.
Change the flags that control the discard, and return true if this call
has resulted in a change to the releasable state.

@return
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;
    }
1057542
public boolean clear() {
        if (!isMutable()) { throw new IllegalStateException("Cannot clear a non-mutable MDict"); }

        if (valCount == 0) { return true; }

        mutate();
        valueMap.clear();

        if (flDict != null) {
            final FLDictIterator itr = new FLDictIterator();
            try {
                itr.begin(flDict);
                String key;
                while ((key = itr.getKeyString()) != null) {
                    valueMap.put(key, MValue.EMPTY);
                    if (!itr.next()) { break; }
                }
            }
            finally {
                itr.free();
            }
        }

        valCount = 0;
        return true;
    }
882715
@Override
    public boolean isDirty() {
        return rewrite || delegate.size() > firstAppendedIndex || !modifiedIndexes.isEmpty() || getDirtyKeys().hasNext();
    }
687433
@Override
    public void discard() {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "discard: " + getStateName(state));

        // d639281 - Singleton instances are never actually discarded unless a
        // failure occurs during initialize().
        if (state == PRE_CREATE || state == CREATING) {
            setState(DESTROYED);

            // Release any JCDI creational contexts that may exist.      F743-29174
            this.releaseManagedObjectContext();

            if (pmiBean != null) {
                pmiBean.discardCount(); // F743-27070
                pmiBean.beanDestroyed();
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "discard");
    }
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();
    }
1371327
public boolean isChanged() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isChanged");
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isChanged",  changed);
    return changed;
  }
325815
private boolean hasFileChangedUnexpectedly() {
        synchronized (this) {
            if (mDiskWritesInFlight > 0) {
                // If we know we caused it, it's not unexpected.
                if (DEBUG) System.out.println( "disk write in flight, not unexpected.");
                return false;
            }
        }
        if (!mFile.canRead()) {
            return true;
        }
        synchronized (this) {
            return mStatTimestamp != mFile.lastModified() || mStatSize != mFile.length();
        }
    }
744666
private boolean switchAndCheckAbort() {
    if (Thread.holdsLock(cache.lock)) {
      return switchCheckAndAbortLocked();
    }
    return cache.executeWithGlobalLock(new Job<Boolean>() {
      @Override
      public Boolean call() {
        return switchCheckAndAbortLocked();
      }
    });
  }
492457
private boolean doTryUpdateNoLock(S storable) {
        S existing = mMap.get(new Key<S>(storable, mFullComparator));
        if (existing == null) {
            return false;
        } else {
            // Copy altered values to existing object.
            existing.markAllPropertiesDirty();
            storable.copyDirtyProperties(existing);
            existing.markAllPropertiesClean();

            // Copy all values to user object, to simulate a reload.
            storable.markAllPropertiesDirty();
            existing.copyAllProperties(storable);
            storable.markAllPropertiesClean();

            return true;
        }
    }
241408
public boolean lockIfNotDisposed() {
    boolean result = false;
    if (this.panelLocker != null) {
      this.panelLocker.lock();
      if (this.disposed.get()) {
        this.panelLocker.unlock();
      } else {
        result = true;
      }
    }
    return result;
  }
714044
public boolean isModified()
  {
    I instance = _instance;

    if (instance == null) {
      return true;
    }
    
    if (DeployMode.MANUAL.equals(_strategy.redeployMode())) {
      return false;
    }
    
    return instance.isModified();
  }
43604
protected boolean isOperationOnMovedResource() {

        Iterator<String> i = getResourceList().iterator();
        while (i.hasNext()) {
            String resName = i.next();
            String target = resourceOriginalPath(getCms(), resName);
            if ((target != null) && !target.equals(resName)) {
                // found a moved resource
                return true;
            }
        }
        return false;
    }
1346739
public boolean isAmendable() {
		if (getTimestamp() == null) {
			return false;
		}
		long now = Utils.timestamp();
		// check timestamp for recent correction,
		return (getTimestamp() + (Config.VOTE_LOCKED_AFTER_SEC * 1000)) > now;
	}
696740
public boolean onRefresh()
    {
        Record record = this.getMainRecord();
        if (record == null)
            return false;

        try
        {
            if (record.getEditMode() == Constants.EDIT_IN_PROGRESS)
            {   // If they're adding, can't delete nothing!
                if (record.isRefreshedRecord())
                    return this.onDelete();
                Object bookmark = record.getHandle(DBConstants.BOOKMARK_HANDLE);
                record.setHandle(bookmark, DBConstants.BOOKMARK_HANDLE);
            }
            if (record.getEditMode() == Constants.EDIT_ADD)
                record.addNew();
            this.clearStatusText();
        } catch (DBException ex) {
            this.displayError(ex);
            return false;
        }
        return true;
    }
1333401
public final function clearModified()
    {
        foreach ($this as $name => $value) {
            $this->_state[$name] = $value;
        }
        return $this;
    }
94674
private boolean hasChangedPosition(I_CmsDropTarget target) {

        if ((m_currentTarget != target) || (m_currentIndex != target.getPlaceholderIndex())) {
            m_currentTarget = target;
            m_currentIndex = target.getPlaceholderIndex();
            return true;
        }
        return false;
    }
758608
public boolean revert() {
        try {
            setWrongValueMessage(null);
            setValue(propInfo.getPropertyValue(target));
            updateValue();
            return true;
        } catch (Exception e) {
            setWrongValueException(e);
            return false;
        }
    }