end checkState  ## CHANGESTATE ## Modifies the private variable my.state. Used in async.chain which takes a callback with single error argument.
510422
function changeState ( item, type, cb) {
    var i
    switch (type) {
    case 'add':
      my.state.trackedfiles[item] = true;
      break
    case 'rm':
      for (i in my.state.trackedfiles) {
        if (path.basename(i) === path.basename(item)) {
          delete my.state.trackedfiles[i];
        }
      }
      break
    default:
      throw new Error('Wrong arguments for function changeState')
    }
    return cb(null)
  }
755352
function(state, data){
      if (this.delegate)
        return this.root.setState(state, data);
      else
        return AbstractData.prototype.setState.call(this, state, data);
    }
503112
function setState(state) {
        return function (job, arg0, arg1) {
            job._setState(state, arg0, arg1);
        };
    }
84328
def notify_state(node, state, latency = nil)
      @lock.synchronize do
        if running?
          update_current_state(node, state, latency)
        end
      end
    rescue => ex
      logger.error("Error handling state report #{[node, state].inspect}: #{ex.inspect}")
      logger.error(ex.backtrace.join("\n"))
    end
658965
function init() {
    var stateFromHash = getStateFromHash();
    var stateChanged = false;

    if (typeof defaults === 'object' && defaults) {
      Object.keys(defaults).forEach(function(key) {
        if (key in stateFromHash) return;

        stateFromHash[key] = defaults[key]
        stateChanged = true;
      });
    }

    if (stateChanged) set(stateFromHash);
  }
1289376
function (stateName) {
            this.$Frame.changeState.call(this, stateName); // this must be
            // called before
            // assigning
            // cssPrefix
            var cfg = this._cfg, cssPrefix = this._cssPrefix, tr, td, getDomElementChild = ariaUtilsDom.getDomElementChild;

            this._computeSize();

            var tds = this._tds;
            if (!tds) {
                tds = [];
                this._tds = tds;
                var tbody = getDomElementChild(this._domElt, 0);
                // Line 1
                tr = getDomElementChild(tbody, 0);
                td = getDomElementChild(tr, 0);
                tds.push({
                    element : td,
                    cssPart1 : 'tlc ',
                    cssPart2 : 'bkgA'
                });
                td = getDomElementChild(tr, 1);
                tds.push({
                    element : td,
                    cssPart1 : 'ts ',
                    cssPart2 : 'bkgB'
                });
                td = getDomElementChild(tr, 2);
                tds.push({
                    element : td,
                    cssPart1 : 'trc ',
                    cssPart2 : 'bkgA'
                });
                // Line 2
                tr = getDomElementChild(tbody, 1);
                td = getDomElementChild(tr, 0);
                tds.push({
                    element : td,
                    cssPart1 : 'ls ',
                    cssPart2 : 'bkgC'
                });
                td = getDomElementChild(tr, 1);
                tds.push({
                    element : td,
                    cssPart : 'm'
                });
                td = getDomElementChild(tr, 2);
                tds.push({
                    element : td,
                    cssPart1 : 'rs ',
                    cssPart2 : 'bkgC'
                });
                // Line 3
                tr = getDomElementChild(tbody, 2);
                td = getDomElementChild(tr, 0);

                tds.push({
                    element : td,
                    cssPart1 : 'blc ',
                    cssPart2 : 'bkgA'
                });
                td = getDomElementChild(tr, 1);
                tds.push({
                    element : td,
                    cssPart1 : 'bs ',
                    cssPart2 : 'bkgB'
                });

                td = getDomElementChild(tr, 2);

                tds.push({
                    element : td,
                    cssPart1 : 'brc ',
                    cssPart2 : 'bkgA'

                });

            }

            var sizeInfo = {
                className : 'xFrameContent ' + cssPrefix + 'c ' + cfg.cssClass
            };
            this._appendInnerSizeInfo(sizeInfo);
            this._childRootElt.style.width = sizeInfo.width;
            this._childRootElt.style.height = sizeInfo.height;
            this._childRootElt.className = sizeInfo.className;

            for (var i = 0, l = tds.length; i < l; i++) {
                td = tds[i];
                if (td.cssPart) {
                    td.element.className = cssPrefix + 'm';
                } else {
                    td.element.className = cssPrefix + td.cssPart1 + cssPrefix + td.cssPart2;
                }
                // frameIcons update
                if (i == 1) {
                    td.element.innerHTML = this.__addFrameIcon(cfg, cssPrefix, 'top');
                }
                if (i == 7) {
                    td.element.innerHTML = this.__addFrameIcon(cfg, cssPrefix, 'bottom');
                }
            }
        }
680129
@Override
    public void onReloadRequired(Map<String, ServerState> states) {
        ReloadState reloadState = MODULES.getReloadState();
        reloadState.updateFrom(states);
        reloadState.propagateChanges();
    }
857738
function isWriteOnStateVariable (effectNode, stateVariables) {
  return isInlineAssembly(effectNode) || (isEffect(effectNode) && isStateVariable(getEffectedVariableName(effectNode), stateVariables))
}
817465
def setModified( self, state = True ):
        
        if ( state == self._modified ):
            return
            
        self._modified = state
        self.emitModifiedStateChanged()
939755
def update_state(self, name, state):
        

        self._loop.run_coroutine(self._client.update_state(name, state))
634301
def change_state_to(state_name, new_state, trigger = true)
      # use an instance variable for the state storage
      ivar_name = :"@#{state_name}"

      old_state = instance_variable_get(ivar_name)
      instance_variable_set(ivar_name, new_state)

      # Trigger changed on the 'state' method
      if old_state != new_state && trigger
        dep = state_dep_for(state_name, false)
        dep.changed! if dep
      end
    end
988509
def set_state(k, v)
        if @state[k] != v # Only set state if it has actually changed
          @state[k] = v

          if !self.methods.include? k
            self.define_singleton_method(k.to_sym) do
              return State.new(@state[k])
            end
          end

          notify_listeners(k)
        end
      end
1368177
function changeState(state, url, replace, lastURLValue) {
    if (!isSupportHistoryAPI) {
      // if not used implementation history.location
      if (isUsedHistoryLocationFlag === 0) isUsedHistoryLocationFlag = 2;
      // normalization url
      var urlObject = parseURL(url, isUsedHistoryLocationFlag === 2 && ('' + url).indexOf("#") !== -1);
      // if current url not equal new url
      if (urlObject._relative !== parseURL()._relative) {
        // if empty lastURLValue to skip hash change event
        lastURL = lastURLValue;
        if (replace) {
          // only replace hash, not store to history
          windowLocation.replace("#" + urlObject._special);
        } else {
          // change hash and add new record to history
          windowLocation.hash = urlObject._special;
        }
      }
    } else {
      lastURL = windowLocation.href;
    }
    if (!isSupportStateObjectInHistory && state) {
      stateStorage[windowLocation.href] = state;
    }
    isFireInitialState = false;
  }
518161
function update(state, updater, description) {
    if (!state.__store__) {
        throw new Error('[Pastate] You can only operate pastate immutable state');
    }
    return state.__store__.update(state, updater, description);
}
205324
private void updateState(X509Certificate currCert)
        throws CertPathValidatorException
    {
        PublicKey cKey = currCert.getPublicKey();
        if (debug != null) {
            debug.println("BasicChecker.updateState issuer: " +
                currCert.getIssuerX500Principal().toString() + "; subject: " +
                currCert.getSubjectX500Principal() + "; serial#: " +
                currCert.getSerialNumber().toString());
        }
        if (PKIX.isDSAPublicKeyWithoutParams(cKey)) {
            // cKey needs to inherit DSA parameters from prev key
            cKey = makeInheritedParamsKey(cKey, prevPubKey);
            if (debug != null) debug.println("BasicChecker.updateState Made " +
                                             "key with inherited params");
        }
        prevPubKey = cKey;
        prevSubject = currCert.getSubjectX500Principal();
    }
1317801
private synchronized void setState(int state) {
        mState = state;

        // Give the new state to the Handler so the UI Activity can update
        mHandler.obtainMessage(ISOBlueDemo.MESSAGE_STATE_CHANGE, state, -1)
                .sendToTarget();
    }
554527
function ChainState() {
  if (!(this instanceof ChainState))
    return new ChainState();

  this.startHeight = -1;
  this.startHash = encoding.NULL_HASH;
  this.height = -1;
  this.marked = false;
}