Set a configuration parameter to the given value.
512591
def config_set(self, parameter, value):
        """"""
        if not isinstance(parameter, str):
            raise TypeError("parameter must be str")
        fut = self.execute(b'CONFIG', b'SET', parameter, value)
        return wait_ok(fut)
885370
def put(self, path, value):
        
        return lib.zconfig_put(self._as_parameter_, path, value)
385448
def set_param(self, number, value):
        
        logger.debug("setting param number %s to %s" % (number, value))
        type_ = param_types[number]
        return self.library.Cli_SetParam(self.pointer, number,
                                         byref(type_(value)))
912272
def set_param(self, param, value):
        ''''''
        self.data[param] = value
        self._object.configuration_data = utils.dict_to_nvlist(self.data)
202187
public MethodConfig setParameter(String key, String value) {
        if (parameters == null) {
            parameters = new ConcurrentHashMap<String, String>();
        }
        parameters.put(key, value);
        return this;
    }
106309
def set(self, value):
        """"""
        if self.validate(value):
            #print "Parameter " + self.id + " successfully set to " + repr(value)
            self.hasvalue = True
            if isinstance(value, float):
                self.value = round(value)
            else:
                self.value = int(value)
            return True
        else:
            #print "Parameter " + self.id + " COULD NOT BE set to " + repr(value)
            return False
730642
public FeatureState setParameter(String name, String value) {
        if (value != null) {
            this.parameters.put(name, value);
        }
        else {
            this.parameters.remove(name);
        }
        return this;
    }
1183499
private static void setScalarParam(String name, Object value) throws ConfigurationException {
        try {
            Field field = config.getClass().getDeclaredField(name);
            field.set(config, value);
        } catch (SecurityException | NoSuchFieldException | IllegalAccessException e) {
            throw new ConfigurationException("Unknown configuration parameter: " + name);
        } catch (IllegalArgumentException e) {
            throw new ConfigurationException("Couldn't parse parameter: " + value);
        }
    }
249229
def set_param(self, name, value):
        
        if name not in self.param_names:
            raise ValueError('No GO-PCA Server parameter named "%s"!' %(param))
        self.__params[name] = value
767166
public T withParam(String name, String value) {
        parameters.put(name, value);
        return self;
    }
320717
def _set_value(self, new_value):
        """"""

        if self.min_value is not None and new_value < self.min_value:

            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is less than the minimum allowed {2}".format(
                    self.name, new_value, self.min_value))

        if self.max_value is not None and new_value > self.max_value:
            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is more than the maximum allowed {2}".format(
                    self.name, new_value, self.max_value))

        # Issue a warning if there is an auxiliary variable, as the setting does not have any effect
        if self.has_auxiliary_variable():

            with warnings.catch_warnings():

                warnings.simplefilter("always", RuntimeWarning)

                warnings.warn("You are trying to assign to a parameter which is either linked or "
                              "has auxiliary variables. The assignment has no effect.", RuntimeWarning)

        # Save the value as a pure floating point to avoid the overhead of the astropy.units machinery when
        # not needed

        if self._transformation is None:

            new_internal_value = new_value

        else:

            new_internal_value = self._transformation.forward(new_value)

        # If the parameter has changed, update its value and call the callbacks if needed

        if new_internal_value != self._internal_value:

            # Update
            self._internal_value = new_internal_value

            # Call the callbacks (if any)
            for callback in self._callbacks:

                try:

                    callback(self)

                except:

                    raise NotCallableOrErrorInCall("Could not call callback for parameter %s" % self.name)
633281
def set(self, section, option, value):
        """"""
        if not value:
            value = '!!False!!'
        if self.is_secure_option(section, option):
            self.set_secure(section, option, value)
        else:
            ConfigParser.set(self, section, option, value)
203052
def set_value(self, value):
        """"""
        if not isinstance(value, str):
            raise TypeError("A value must be a string, got %s." % value)
        self.__value = value
1203222
def set(name, value)
      if respond_to?(name)
        send("#{name}=",value)
      elsif Configuration.setting_name_to_property(name)
        send("#{Configuration.setting_name_to_property(name)}=",value)
      else
        build_settings[name] = value
      end
    end
1131286
def set( self, params ):
        """"""
        if self._parameters is not None:
            self.deconfigure()
        self.configure(params)
        return self
1111065
function setParameter($name, $value)
    {
        $this->name = $name;
        $this->value = $value;

        return $this;
    }
1094198
public synchronized void setOption(String key, String value)
	{
		if (key == null || value == null) {
			return;
		}
		config.put(key, value);
	}