MNStorage.systemMetadataChanged(session, did, serialVersion,
    dateSysMetaLastModified) → boolean.
502404
def post_refresh_system_metadata(request):
    """"""
    d1_gmn.app.views.assert_db.post_has_mime_parts(
        request,
        (
            ('field', 'pid'),
            ('field', 'serialVersion'),
            ('field', 'dateSysMetaLastModified'),
        ),
    )
    d1_gmn.app.views.assert_db.is_existing_object(request.POST['pid'])
    d1_gmn.app.models.sysmeta_refresh_queue(
        request.POST['pid'],
        request.POST['serialVersion'],
        request.POST['dateSysMetaLastModified'],
        'queued',
    ).save()
    return d1_gmn.app.views.util.http_response_with_boolean_true_type()
678997
@Override
  public final void handleModelChanged(final ReplicationAccMethod pModel) {
    if (this.replicationMethod != null
      && this.replicationMethod.getItsId().equals(pModel.getItsId())) {
      this.replicationMethod = null;
    }
  }
609176
public void checkCacheMode(Boolean boolShouldBeCached)
    {
        try {
            boolean bCurrentlyCached = (this.getRemoteTableType(CachedRemoteTable.class) != null);
            if ((this.getRecord().getOpenMode() & DBConstants.OPEN_CACHE_RECORDS) == DBConstants.OPEN_CACHE_RECORDS)
                boolShouldBeCached = Boolean.TRUE;
//            if ((this.getRecord().getOpenMode() & DBConstants.OPEN_READ_ONLY) == DBConstants.OPEN_READ_ONLY);
//                    bShouldBeCached = true;
            if ((this.getRecord().getOpenMode() & DBConstants.OPEN_DONT_CACHE) == DBConstants.OPEN_DONT_CACHE)
                boolShouldBeCached = Boolean.FALSE;
            if (boolShouldBeCached == null)
                return;     // Not specified, Don't change.
            if ((!bCurrentlyCached) && (boolShouldBeCached.booleanValue()))
            {   // Add a cache
                Utility.getLogger().info("Cache ON: " + this.getRecord().getTableNames(false));
                this.setRemoteTable(new CachedRemoteTable(m_tableRemote));
            }
            else if ((bCurrentlyCached) && (!boolShouldBeCached.booleanValue()))
            {   // Remove the cache
                Utility.getLogger().info("Cache OFF: " + this.getRecord().getTableNames(false));
//                RemoteTable tableRemote = this.getRemoteTableType(org.jbundle.model.Remote.class);
                RemoteTable tableRemote = this.getRemoteTableType(CachedRemoteTable.class).getRemoteTableType(null);
                ((CachedRemoteTable)m_tableRemote).setRemoteTable(null);
                ((CachedRemoteTable)m_tableRemote).free();
                this.setRemoteTable(tableRemote);
            }
        } catch (RemoteException ex)    {
            // Never for this usage
        }
    }
761639
@Override
	protected synchronized void checkDataMaps() throws IOException {
		if (lastUpdateCheck == 0 || lastUpdateCheck < System.currentTimeMillis() - updateInterval) {
			String versionOnServer = getVersionFromServer();
			if (currentVersion == null || versionOnServer.compareTo(currentVersion) > 0) {
				loadDataFromInternetAndSave();
				loadDataFromFile(getCacheFile());
				currentVersion = versionOnServer;
				prop.setProperty("currentVersion", currentVersion);
			}
			lastUpdateCheck = System.currentTimeMillis();
			prop.setProperty("lastUpdateCheck", Long.toString(lastUpdateCheck));
			saveProperties(prop);
		}
	}
1008362
@Override
    public synchronized boolean load() {
        Either<Void, T> oldData = data;
        String oldKey = versionedKey;
        try {
            if (isOutOfDate()) {
                String newVersionedKey = (String) connection.get(key)
                                                            .get();
                data = Either.right((T) nonAtomicload(newVersionedKey));
                versionedKey = newVersionedKey;
            } else {
                return false;
            }
        } catch (Throwable e) {
            data = oldData;
            versionedKey = oldKey;
            logger.debug(e.getMessage(), e);
            throw ExceptionSoftener.throwSoftenedException(e);
        }
        return true;
    }
1275969
@Override
    protected void wasModified(AuthzTrans trans, CRUD modified, Data data, String ... override) {
    	boolean memo = override.length>0 && override[0]!=null;
    	boolean subject = override.length>1 && override[1]!=null;

        HistoryDAO.Data hd = HistoryDAO.newInitedData();
        hd.user = trans.user();
        hd.action = modified.name();
        hd.target = TABLE;
        hd.subject = subject?override[1]:data.user + "|" + data.approver;
        hd.memo = memo
                ? String.format("%s by %s", override[0], hd.user)
                : (modified.name() + "d approval for " + data.user);
        // Detail?
        // Reconstruct?
        if(historyDAO.create(trans, hd).status!=Status.OK) {
        	trans.error().log("Cannot log to History");
        }
    }
1002329
public boolean isModifiedOnVersion(String version) {
		if (version == null || version.isEmpty()) {
			return true;
		}
		if (this.history != null && this.history.isModifiedOnVersion(version)) {
			return true;
		}
		if (this.fields != null) {
			for (APIParameter param : this.fields) {
				if (param.isModifiedOnVersion(version)) {
					return true;
				}
			}
		}
		return false;
	}
846594
public function isChanged()
    {
        $snapshot = $this->_snapshot;
        if (!is_array($snapshot)) {
            return true;
        }
        $metadata = $this->getModelsMetaData();
        $attrs = $metadata->getNonPrimaryKeyAttributes($this);
        $automatic = $metadata->getAutomaticUpdateAttributes($this);
        $bindDataTypes = $metadata->getBindTypes($this);
        foreach ($attrs as $name) {
            if (isset($automatic[$name])) {
                continue;
            }
            $value = $this->readAttribute($name);
            $snapshotValue = ArrayHelper::fetch($snapshot, $name);
            if ($value === null) {
                if ($snapshotValue !== null) {
                    return true;
                }
            } else {
                if ($snapshotValue === null) {
                    return true;
                }
                $bindType = ArrayHelper::fetch($bindDataTypes, $name);
                switch ($bindType) {
                    case Column::TYPE_DATE:
                    case Column::TYPE_VARCHAR:
                    case Column::TYPE_DATETIME:
                    case Column::TYPE_CHAR:
                    case Column::TYPE_TEXT:
                    case Column::TYPE_VARCHAR:
                    case Column::TYPE_BIGINTEGER:
                        if (((string)$value) !== ((string)$snapshotValue)) {
                            return true;
                        }
                        break;
                    default:
                        if ($value != $snapshotValue) {
                            return true;
                        }
                }
            }
        }
        return false;
    }
118182
public boolean getAutoRemoved(){
        Map<String, String> meta = getMetadata();
        if (meta!=null&&meta.containsKey("autoRemoved")){
            return !"false".equals(meta.get("autoRemoved"));
        }
        return true;
    }
441246
boolean isValidCopy(BackedSession sess, long nowTime, int versionId) {
        synchronized (sess) {
            if (!sess.isValid())
                return false;

            int maxTime = sess.getMaxInactiveInterval();
            boolean accBeforeTO = (sess.getCurrentAccessTime() >= nowTime - (1000 * (long) maxTime));//PK90548
            boolean cacheIdMatch = (sess.getVersion() >= versionId);

            return (cacheIdMatch && (accBeforeTO || maxTime == -1));
        }
    }
399772
private boolean writeMetaData(final boolean isClean) {
		if (readOnly) {
			return true;
		}
		final WriteBuffer wbuf = storage.set(0);
		final ByteBuffer buf = wbuf.buf();
		boolean isOK = false;
		// @formatter:off
		buf
		.putInt(MAGIC_1)
		.putInt(blockSize)
		.putInt(b_order_leaf)
		.putInt(b_order_internal)
		.putInt(storageBlock)
		.putInt(rootIdx)
		.putInt(lowIdx)
		.putInt(highIdx)
		.putInt(elements)
		.putInt(height)
		.putInt(maxInternalNodes)
		.putInt(maxLeafNodes)
		.put((byte) (isClean ? 0xEA : 0x00))
		.putInt(MAGIC_2)
		.flip();
		// @formatter:on
		isOK = wbuf.save();
		if (isClean) {
			storage.sync();
		}
		try {
			if (isClean) {
				SimpleBitSet.serializeToFile(fileFreeBlocks, freeBlocks);
			} else {
				fileFreeBlocks.delete();
			}
		} catch (IOException e) {
			log.error("IOException in writeMetaData(" + isClean + ")", e);
		}
		if (log.isDebugEnabled()) {
			log.debug(this.getClass().getName() + "::writeMetaData() elements=" + elements + " rootIdx="
					+ rootIdx + " lastNodeId=" + storageBlock + " freeBlocks=" + freeBlocks.cardinality());
		}
		return isOK;
	}
223339
def _is_updated(old_conf, new_conf):
    '''
    
    '''
    changed = {}

    # Dirty json hacking to get parameters in the same format
    new_conf = _json_to_unicode(salt.utils.json.loads(
        salt.utils.json.dumps(new_conf, ensure_ascii=False)))
    old_conf = salt.utils.json.loads(salt.utils.json.dumps(old_conf, ensure_ascii=False))

    for key, value in old_conf.items():
        oldval = six.text_type(value).lower()
        if key in new_conf:
            newval = six.text_type(new_conf[key]).lower()
        if oldval == 'null' or oldval == 'none':
            oldval = ''
        if key in new_conf and newval != oldval:
            changed[key] = {'old': oldval, 'new': newval}
    return changed
1148666
public void valueHasChanged(DCache cache, Object id, long expirationTime, int inactivity) {  // CPF-Inactivity
        //final String methodName = "valueHasChanged()";
        if (expirationTime <= 0 && inactivity <=0 ) { // CPF-Inactivity
            throw new IllegalArgumentException("expirationTime or inactivity must be positive");
        }
        if ( UNIT_TEST_INACTIVITY ) {
            System.out.println(" valueHasChanged() - entry");
            System.out.println(" expirationTime="+expirationTime);
            System.out.println(" inactivity="+inactivity);
        }
        // CPF-Inactivity
        //-----------------------------------------------------------
        // Force an expriationTime if we have an inactivity timer
        //-----------------------------------------------------------
        boolean isInactivityTimeOut = false;
        if ( inactivity > 0 ) {
            // For 7.0, use QuickApproxTime.getRef.getApproxTime()
            long adjustedExpirationTime = System.currentTimeMillis() + ( inactivity * 1000 );
            if ( adjustedExpirationTime < expirationTime ||
                 expirationTime <= 0 ) {
                expirationTime = adjustedExpirationTime;
                isInactivityTimeOut = true;
            }
        }
        ExpirationMetaData expirationMetaData = (ExpirationMetaData)cacheInstancesTable.get(cache);
        // Just make sure expirationMetaData is NOT NULL in case of an internal-error condition
        if (expirationMetaData == null) {
            return;
        }
        synchronized (expirationMetaData) {
            InvalidationTask it = (InvalidationTask) expirationMetaData.expirationTable.get(id);
            if (it == null) {
                it = (InvalidationTask) taskPool.remove();
                it.id = id;
                expirationMetaData.expirationTable.put(id, it);
            } else {
                expirationMetaData.timeLimitHeap.delete(it);
            }
            it.expirationTime = expirationTime;
            it.isInactivityTimeOut = isInactivityTimeOut;
            expirationMetaData.timeLimitHeap.insert(it);
            //ccount++;
            //traceDebug(methodName, "cacheName=" + cache.getCacheName() + " id=" + id + " expirationTableSize=" + expirationMetaData.expirationTable.size() + " timeLimitHeapSize=" + expirationMetaData.timeLimitHeap.size() + " count=" + ccount);
        }
    }
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;
  }
992851
function () {
            ariaStorageEventBus.stop = true;
            this._clear();
            ariaStorageEventBus.stop = false;

            ariaStorageEventBus.notifyChange(this.type, null, null, null);
        }
416547
def _dep_changed(self, dep, code_changed=False, value_changed=False):
        
        self.changed(code_changed, value_changed)
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;
    }