Setter for 'process_ref' field.
        :param value - a new value of 'process_ref' field. Must be either None (process_ref is optional according to
        BPMN 2.0 XML Schema) or String.
961376
def set_process_ref(self, value):
        
        if not isinstance(value, str):
            raise TypeError("ProcessRef must be set to a String")
        self.__process_ref = value
896416
def setValue(self, value):
        
        if isinstance(value, Text):
            self.value = value
        else:
            self.value = Text(value)
        return self
878606
def validate_value(self, value):
        
        field = self.instance.preference.setup_field()
        value = field.to_python(value)
        field.validate(value)
        field.run_validators(value)
        return value
950125
def _process_param_value(self, value):
        
        # Extract IDs from objects
        if isinstance(value, TroveboxObject):
            return str(value.id).encode('utf-8')

        # Ensure strings are UTF-8 encoded
        elif isinstance(value, TEXT_TYPE):
            return value.encode("utf-8")

        # Handle lists
        elif isinstance(value, list):
            # Make a copy of the list, to avoid overwriting the original
            new_list = list(value)
            # Process each item in the list
            for i, item in enumerate(new_list):
                new_list[i] = self._process_param_value(item)
            # new_list elements are UTF-8 encoded strings - simply join up
            return b','.join(new_list)

        # Handle booleans
        elif isinstance(value, bool):
            return b"1" if value else b"0"

        # Unknown - just do our best
        else:
            return str(value).encode("utf-8")
322063
public void setProcessForm(boolean processForm) {
		this.processForm = processForm;
		getConfig().setProperty(SPIDER_PROCESS_FORM, Boolean.toString(processForm));
	}
31777
def set(self, param, value):
        
        self._shouldOwn(param)
        try:
            value = param.typeConverter(value)
        except ValueError as e:
            raise ValueError('Invalid param value given for param "%s". %s' % (param.name, e))
        self._paramMap[param] = value
1011447
def set(self, name, value):
        
        flag = self.flags[name]
        self._value = (self.value | flag) if value else (self.value & ~flag)
1264373
protected void setValue(String value, boolean fireEvent) {

        m_textbox.setValue(value);
        updateUploadTarget(CmsResource.getFolderPath(value));
        updateResourceInfo(value);
        m_previousValue = value;
        if (fireEvent) {
            fireChange(true);
        }
    }
432360
def _set(self, instance, value, **kw):
        
        logger.debug("DexterityFieldManager::set: value=%r" % value)

        # Check if the field is read only
        if self.field.readonly:
            raise Unauthorized("Field is read only")

        fieldname = self.get_field_name()
        # id fields take only strings
        if fieldname == "id":
            value = str(value)

        try:
            # Validate
            self.field.validate(value)

            # TODO: Check security on the field level
            return self.field.set(instance, value)
        except WrongType:
            logger.warn("WrongType: Field={} Value={}".format(self.field, value))
        except:  # noqa
            logger.warn("Unknown Exception: Field={} Value={}".format(self.field, value))
622637
def set_field_value(self, name, value):
        
        name = self.get_real_name(name)

        if not name or not self._can_write_field(name):
            return

        if name in self.__deleted_fields__:
            self.__deleted_fields__.remove(name)
        if self.__original_data__.get(name) == value:
            try:
                self.__modified_data__.pop(name)
            except KeyError:
                pass
        else:
            self.__modified_data__[name] = value
            self._prepare_child(value)
            if name not in self.__structure__ or not self.__structure__[name].read_only:
                return

            try:
                value.set_read_only(True)
            except AttributeError:
                pass
491499
def set( self, instance, value, **kwargs ):
        
        if not self._allow_write:
            raise AttributeError( "can't set Ref directly, allow_write is disabled" )
        target = instance
        for attr in self._path[:-1]:
            target = getattr( target, attr )
        setattr( target, self._path[-1], value )
        return
195202
def set(self, value: Optional[bool]):
        
        prev_value = self._value
        self._value = value
        if self._value != prev_value:
            # notify all watchers that this check was changed
            for event in self._events:
                event.set()
324717
def process_result_value(self, value, dialect):
        
        if value is not None:
            cmd = "value = {}".format(value)
            exec(cmd)
        return value
344515
def set_flow_node_ref_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("FlowNodeRefList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, str):
                    raise TypeError("FlowNodeRefList elements in variable must be of String class")
            self.__flow_node_ref_list = value
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
587281
def set(self, value):
        '''
        
        '''
        with self._reference.get_lock():
            self._reference.value = value
            return value
317223
def set(self, value):
        

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

        if isinstance(value, str_cls):
            if value not in self._reverse_map:
                raise ValueError(unwrap(
                    '''
                    %s value "%s" is not a valid value
                    ''',
                    type_name(self),
                    value
                ))

            value = self._reverse_map[value]

        elif value not in self._map:
            raise ValueError(unwrap(
                '''
                %s value %s is not a valid value
                ''',
                type_name(self),
                value
            ))

        Integer.set(self, value)