Callback when a gconf key changes
437461
def _key_changed(self, client, cnxn_id, entry, data=None):
        
        key = self._fix_key(entry.key)[len(self.GCONF_DIR):]
        value = self._get_value(entry.value, self.DEFAULTS[key])

        self.emit('conf-changed', key, value)
80504
function ConfigStack(){
  this._stack = new Uint32Array( ( (LEN|0) * MIN_ALLOC)|0 );
  this._sets  = new Uint32Array( MIN_ALLOC|0 );
  this._tmpDat = new Uint32Array( LEN|0 );
  this._size  = MIN_ALLOC|0;
  this._ptr   = 0;

  this._headPos = 0;
  this._wcfg = new GLConfig();
}
328486
def global_config(cls, key, *args):
        '''  '''
        if args:
            cls.settings[key] = args[0]
        else:
            return cls.settings[key]
669941
def on_state_changed(self, state):
        """"""
        if state:
            self.editor.sig_key_pressed.connect(self._on_key_pressed)
        else:
            self.editor.sig_key_pressed.disconnect(self._on_key_pressed)
840537
def _domain_event_tray_change_cb(conn, domain, dev, reason, opaque):
    '''
    
    '''
    _salt_send_domain_event(opaque, conn, domain, opaque['event'], {
        'dev': dev,
        'reason': _get_libvirt_enum_string('VIR_DOMAIN_EVENT_TRAY_CHANGE_', reason)
    })
611526
public static String[] adjustConf(String[] argv, Configuration conf) {
    String[] serviceId = new String[] { "" };
    String[] filteredArgv = DFSUtil.getServiceName(argv, serviceId);
    if (!serviceId[0].equals("")) {
      NameNode.checkServiceName(conf, serviceId[0]);
      DFSUtil.setGenericConf(conf, serviceId[0],
          AvatarNode.AVATARSERVICE_SPECIFIC_KEYS);
      NameNode.setupDefaultURI(conf);
    }
    return filteredArgv;
  }
69097
def _wait_new_conf(self):
        
        with self.app.conf_lock:
            logger.warning("My master Arbiter wants me to wait for a new configuration.")
            self.app.cur_conf = {}
1081016
function _callback(changed_keys) {
      if (intersection(keys_to_watch_for_changes, changed_keys).length) {
        // only update the state if a key we care about has changed
        var state_update_obj = {};
        keys_to_watch_for_changes.forEach(function (k) {
          return state_update_obj[k] = store._store[k];
        });
        this.setState(state_update_obj);

        // if some other custom callback is required by the component
        // call that function as well
        if (additonal_callback) {
          additonal_callback(changed_keys);
        }
      }
    }
499848
function (evt) {
            var changedProperties = evt.changedProperties;
            var localCfg = this._localDefCfg;
            var doUpdate = (changedProperties == null); // always do an update on reset
            if (changedProperties) {
                // look if the changed keys are part of this local environment
                for (var i = 0, l = changedProperties.length; i < l; i++) {
                    var propName = changedProperties[i];
                    if (propName in localCfg) {
                        doUpdate = true;
                        break;
                    }
                }
            }
            if (doUpdate) {
                evt.asyncCalls++;
                this._normAndApplyEnv(evt.callback);
            }
        }
427853
def _secret_event_value_changed_cb(conn, secret, opaque):
    '''
    
    '''
    _salt_send_event(opaque, conn, {
        'secret': {
            'uuid': secret.UUIDString()
        },
        'event': opaque['event']
    })
495575
private static void setIfUnset(JobConf conf, String key, String value) {
    if (conf.get(key) == null) {
      conf.set(key, value);
    }
  }
235296
public function onConfigUpdated()
    {
        if ($this->client) {
            $this->client->config = $this->config;
            $this->client->onConfigUpdated();
        }
    }
776200
def set_configs(self, key, d):
        """"""
        if '_config' in self.proxy:
            self.proxy['_config'][key] = d
        else:
            self.proxy['_config'] = {key: d}
856404
private void configureEvent(CacheEntryListenerInvocation listenerInvocation,
                               EventImpl<K, V> e, K key, V value, Metadata metadata) {
      e.setKey(convertKey(listenerInvocation, key));
      e.setValue(convertValue(listenerInvocation, value));
      e.setMetadata(metadata);
      e.setOriginLocal(true);
      e.setPre(false);
   }
31856
def custom_conf(self, conf):
        ''''''
        if conf:
            for (key, val) in conf.items():
                self.__conf[key] = val
        return self
263779
def _domain_event_metadata_change_cb(conn, domain, mtype, nsuri, opaque):
    '''
    
    '''
    _salt_send_domain_event(opaque, conn, domain, opaque['event'], {
        'type': _get_libvirt_enum_string('VIR_DOMAIN_METADATA_', mtype),
        'nsuri': nsuri
    })
886090
function (key, value) {
        var accessor = getAccessors(this)[key],
            oldVal = this.get(key);


        this.triggerBeforeChanged(key, oldVal);

        if (accessor) {
            accessor.target.set(accessor.key, value);
        } else {

            if (this['set_' + key]) {
                this['set_' + key](value);
            } else {
                this[key] = value;
            }
        }
        this.triggerChanged(key, oldVal);
    }