Like set(), but only sets the value if the variable is not already
        defined.

        :type  name: string
        :param name: The name of the variable.
        :type  value: object
        :param value: The value of the variable.
767566
def set_default(self, name, value):
        
        if self.vars is None:
            self.vars = {}
        if name not in self.vars:
            self.vars[name] = value
1218399
def _set(self, name, value):
        
        if value is not UNSET:
            if isinstance(value, Slotted):
                current = getattr(self, name, UNSET)
                if current is None or current is UNSET:
                    current = value.__class__()
                    current.set(value)
                    setattr(self, name, current)
                    return
                if isinstance(current, Slotted):
                    current.set(value)
                    return
            setattr(self, name, value)
1065462
def set(self, name: str, value: Any) -> None:
        
        self.agent.set(name, value)
1364238
def _setable_set_(name, self, func):
        ""

        setattr(self._attr_data_, name, func())

        if hasattr(self._attr_func_, name):
            delattr(self._attr_func_, name)

        setattr(
            type(self),
            name,
            property(
                functools.partial(self._simple_get_, name)
            )
        )
444005
def _set(self, **kwargs):
        
        for param, value in kwargs.items():
            p = getattr(self, param)
            if value is not None:
                try:
                    value = p.typeConverter(value)
                except TypeError as e:
                    raise TypeError('Invalid param value given for param "%s". %s' % (p.name, e))
            self._paramMap[p] = value
        return self
985108
def append(self, name, value):
        
        if self.vars is None:
            self.vars = {}
        if name in self.vars:
            self.vars[name].append(value)
        else:
            self.vars[name] = [value]
1326064
def set_value(self, name, value, ignore_error=False, block_user_signals=False):
        
        # first clean up the name
        name = self._clean_up_name(name)

        # If we're supposed to, block the user signals for this parameter
        if block_user_signals: self.block_user_signals(name, ignore_error)        

        # now get the parameter object
        x = self._find_parameter(name.split('/'), quiet=ignore_error)

        # quit if it pooped.
        if x == None: return None
        
        # for lists, make sure the value exists!!
        if x.type() in ['list']:
            
            # Make sure it exists before trying to set it
            if str(value) in list(x.forward.keys()): x.setValue(str(value))
            
            # Otherwise default to the first key
            else: x.setValue(list(x.forward.keys())[0])
        
        # Bail to a hopeful set method for other types
        else: x.setValue(eval(x.opts['type'])(value))

        # If we're supposed to unblock the user signals for this parameter
        if block_user_signals: self.unblock_user_signals(name, ignore_error)

        return self
987660
def name(self, value):
        

        if isinstance(value, string_types):

            match = Parameter._PARAM_NAME_COMPILER_MATCHER(value)

            if match is None or match.group() != value:
                value = re_compile(value)

        self._name = value
494341
def set_target_variable (self, targets, variable, value, append=0):
        
        if isinstance (targets, str):
            targets = [targets]
        if isinstance(value, str):
            value = [value]

        assert is_iterable(targets)
        assert isinstance(variable, basestring)
        assert is_iterable(value)

        if targets:
            if append:
                bjam_interface.call("set-target-variable", targets, variable, value, "true")
            else:
                bjam_interface.call("set-target-variable", targets, variable, value)
214322
def set(self, name, value, ex=None, px=None, nx=False, xx=False):
        
        self.client.set(name=name, value=value, px=px, nx=nx, xx=xx)
159413
public void set(String name, Object value) {
        if (value != null) {
            attributes.put(name, String.valueOf(value));
        } else {
            attributes.remove(name);
        }

    }
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
1362310
def _setable_get_(name, self):
        ""

        raise AttributeError(
            "'{typename}' object has no attribute '{name}'".format(
                typename=type(self).__name__,
                name=name
            )
        )
1011713
def set(self, value):
        

        if not isinstance(value, str_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a unicode string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        if value.startswith('.'):
            encoded_value = b'.' + value[1:].encode(self._encoding)
        else:
            encoded_value = value.encode(self._encoding)

        self._unicode = value
        self.contents = encoded_value
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
583431
def set (self, id, param, value):
        
        assert isinstance(id, basestring)
        assert isinstance(param, basestring)
        assert is_iterable_typed(value, basestring)
        self.params_.setdefault(param, {})[id] = value
88280
def set(self, name, arg=UNSET):
        
        self._set(name, arg, self._lineno)
443770
public void setIfUnset(String name, String value) {
        if (get(name) == null) {
            set(name, value);
        }
    }