Set the reference configuration.
@param {object}  newConf         - The new configuration to set.
@param {Boolean} isClearPrevious - Does the config should be reset.
425670
function setConfig(newConf, isClearPrevious) {
    checkIsObject(newConf);
    config = isClearPrevious ? Immutable.fromJS(newConf) : config.merge(newConf);
}
1265323
function preferencesInitialize() {
    return this.initializedPromise =
        this._readFromStorage(DEFAULT_PREFERENCES).then(function(prefObj) {
      this.isInitializedPromiseResolved = true;
      if (prefObj) {
        this.prefs = prefObj;
      }
    }.bind(this));
  }
590369
function initChangeDetectorIfExisting(injector, instance, view) {
    if (injector && injector.changeDetectorRef != null) {
        injector.changeDetectorRef._setComponentContext(view, instance);
    }
}
1085987
protected void initializeNewEngineComponent(JsEngineComponent engineComponent) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, "initializeNewEngineComponent", engineComponent);
        }

        // Synchronize on stateChangeLock to manage the startup of the engine with
        // potential addition of new engine components via dynamic config.

        synchronized (stateChangeLock) {

            if (_state != STATE_UNINITIALIZED && _state != STATE_DESTROYED) {
                // Initialize
                engineComponent.initialize(this);
                // Set ME config
                engineComponent.setConfig(this);
            }

            if (_state == STATE_STARTING || _state == STATE_STARTED) {
                // Start engine component (in recovery mode if needed)
                int mode = JsConstants.ME_START_DEFAULT;
                if (_mainImpl.isServerInRecoveryMode() == true) {
                    mode += JsConstants.ME_START_RECOVERY;
                }
                engineComponent.start(mode);
            }

        } // synchronized (stateChangeLock)

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, "initializeNewEngineComponent");
        }
    }
831333
function (defaults, configure) {
        for (var key in defaults) {
            if (defaults.hasOwnProperty(key)) {
                if (typeof defaults[key] === 'object') {
                    // recursive
                    if (typeof configure[key] === 'object') {
                        overwriteConfig(defaults[key], configure[key]);
                    }
                } else {
                    // copy directly
                    if (typeof configure[key] !== 'undefined') {
                        defaults[key] = configure[key];
                    }
                }
            }
        }
    }
1176935
function(config) {
    this._config = this._defaultConfig();
    if (!config) return true;
    
    var datastore;
    
    switch(config.adapter) {
    case 'disk':
      datastore = this._adapters.disk.connection();
      break;
      
    case 'redis':
      datastore = this._adapters.redis.connection(config.redis);
      break;
      
    case 'memory':
    default:
      return true; // Memory adapter by default
    }
    
    // Set connection
    this._config.connections.datastore = datastore;
    return true;
  }
602877
function(refresher_config) {

		if (Lava.schema.DEBUG && (this._refresher || this._current_count)) Lava.t("Foreach: refresher is already created or createRefresher() was called outside of init()");
		if (Lava.schema.DEBUG && !this._container) Lava.t('View/Foreach: refresher needs container to work');

		var constructor = Lava.ClassManager.getConstructor(refresher_config['type'], 'Lava.view.refresher');
		this._refresher = /** @type {Lava.view.refresher.Standard} */ new constructor(refresher_config, this, this._container);

		this._refresher.on('removal_complete', this._onRemovalComplete, this);
		this._refresh = this._refresh_Refresher;
		this._removeTemplates = this._removeTemplates_Refresher;
		this._renderContent = this._renderContent_Refresher;
		this._broadcastToChildren = this._broadcastToChildren_Refresher;

	}
854419
function(conf) {
  Object.defineProperty(this, 'conf',
    {
      enumerable: false,
      configurable: false,
      writable: false,
      value: conf || {}
    }
  );
  if(this.conf.initialize) {
    this.load();
  }
}
256992
void setLastSeenConfig(ClusterConfiguration conf) throws IOException {
    String version = conf.getVersion().toSimpleString();
    File file = new File(rootDir, String.format("cluster_config.%s", version));
    FileUtils.writePropertiesToFile(conf.toProperties(), file);
    // Since the new config file gets created, we need to fsync the directory.
    fsyncDirectory();
  }
879729
public function setPreRenderConfig($preRenderConfig, $replace = false) {
        if(!$replace && $this->preRenderConfig) {
            $this->preRenderConfig->setConfig(array_merge($this->preRenderConfig->getConfig(), $preRenderConfig->getConfig()));
        } else {
            $this->preRenderConfig = $preRenderConfig;
        }
    }
1221662
public void set(V newReference, boolean newMark) {
        Pair<V> current = pair;
        if (newReference != current.reference || newMark != current.mark)
            this.pair = Pair.of(newReference, newMark);
    }
338398
function(config) {
        _cleanup();

        if (!config) config = {};

        _global = config.global || {};
        _partners = config.partners || {};

        if (!_loaded) _loaded = true;
        this.trigger('dynamicConfigChanged');
      }
866590
function setDefaultConfig(defaultNames, packageName, obj) {
  for (let [objName, configName] of defaultNames) {
    atom.config.set(`${packageName}.${configName}`, obj[objName]);
  }
}
546196
def _reset(self):
        
        with self._lock:
            # Start listening to services with the new filter
            self.stop()
            self.start()

            for svc_ref in self.get_bindings():
                # Check if the current reference matches the filter
                if not self.requirement.filter.matches(
                    svc_ref.get_properties()
                ):
                    # Not the case: emulate a service departure
                    # The instance life cycle will be updated as well
                    self.on_service_departure(svc_ref)
1277747
function(key, silent){
            this._configs = this._configs || {};
            if (this._configs[key]) {
                this.set(key, this._configs[key]._initialConfig.value, silent);
                return true;
            }
            return false;
        }
763757
function setDefaults(definition) {
      providerConfig.optionsFactory = definition.options;
      providerConfig.methods = (definition.methods || []).concat(EXPOSED_METHODS);
      return provider;
    }
1251298
function initConfig(conf) {
  const result = Object.assign({}, conf);
  if (conf.filename) {
    result.filepath = path.dirname(conf.filename);
  }
  return result;
}