Set the string representation of logical values.
323937
def logical_repr(self, value):
        """"""
        if not any(isinstance(value, t) for t in (list, tuple)):
            raise TypeError("Logical representation must be a tuple with "
                            "a valid true and false value.")
        if not len(value) == 2:
            raise ValueError("List must contain two values.")

        self.false_repr = value[0]
        self.true_repr = value[1]
1338876
private void set(String key, String... values) {
            String value = get(values);
            
            if (value != null) {
                put(getLabel(key), value);
            }
        }
128624
public void setAttributes(String str)
    {
        str = str.trim();
        String delimiter = ":";    // default is colon delimiter,
        if(str.indexOf(";") != -1) // but use semi-colon with date format parameters (eg. HH:mm)
            delimiter = ";";
        StringTokenizer st = new StringTokenizer(str, delimiter);
        while(st.hasMoreTokens())
        {
            String token = st.nextToken().trim();
            int pos = token.indexOf("=");
            if(pos != -1)
            {
                String name = token.substring(0, pos).trim();
                String value = token.substring(pos+1).trim();

                if(name.equals(TYPE_ATTR))
                {
                    type = getCellType(value);
                }
                else if(name.equals(FORMAT_ATTR))
                {
                    format = value;
                }
                else if(name.equals(INPUT_TYPE_ATTR))
                {
                    inputType = getDataType(value);
                    if(outputType == NO_TYPE)
                        outputType = inputType;
                }
                else if(name.equals(INPUT_FORMAT_ATTR))
                {
                    inputFormat = value;
                }
                else if(name.equals(OUTPUT_TYPE_ATTR))
                {
                    outputType = getDataType(value);
                    if(inputType == NO_TYPE)
                        inputType = outputType;
                }
                else if(name.equals(OUTPUT_FORMAT_ATTR))
                {
                    outputFormat = value;
                }
                else if(name.equals(REGEX_ATTR))
                {
                    regex = value;
                }
                else if(name.equals(NULL_VALUE_ATTR))
                {
                    nullValue = value;
                }
                else if(name.equals(ALIGN_ATTR))
                {
                    align = getAlignment(value);
                }
                else if(name.equals(WRAP_ATTR))
                {
                    wrap = Boolean.parseBoolean(value);
                }
                else if(name.equals(DISPLAY_ATTR))
                {
                    display = value;
                }
            }
        }
    }
966336
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)
            ))

        self._unicode = value
        self.contents = value.encode(self._encoding)
        self._header = None
        if self._indefinite:
            self._indefinite = False
            self.method = 0
        if self._trailer != b'':
            self._trailer = b''
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
798780
def valueFromString(self, value, extra=None, db=None):
        
        return projex.text.nativestring(value).lower() == 'true'
1180112
public void setFormValue(Object value) {

        if (value == null) {
            value = "";
        }
        if (value instanceof String) {
            String strValue = (String)value;
            if (strValue.length() > 0) {
                checkvalue(strValue);
            }
        }

    }
721019
public String set(String value)
    {
        String prevValue = setString(value);
        if (prevValue == null) {
            prevValue = getDefaultValue();
        }
        return prevValue;
    }
732445
def setColumn(self, header, values):
        
        if any(isinstance(value, basestring) for value in values):
            values = list(map(str, values))
            self._impl.setColumnStr(header, values, len(values))
        elif all(isinstance(value, Real) for value in values):
            values = list(map(float, values))
            self._impl.setColumnDbl(header, values, len(values))
        else:
            print(values)
            raise NotImplementedError
1180912
private function setOptionalStrings()
    {
        /*
         *  Make another string t' check fer
         */
        if($this->optional)
        {
            $this->strings[1] = $this->strings[0].Url::SLASH_WORD;
            //reverse the fecker, if the longer one matches first, good!
            $this->strings = array_reverse($this->strings);
        }
    }
792466
def false_repr(self, value):
        """"""
        if isinstance(value, str):
            if not (value.lower().startswith('f') or
                    value.lower().startswith('.f')):
                raise ValueError("Logical false representation must start "
                                 "with 'F' or '.F'.")
            else:
                self._logical_repr[0] = value
        else:
            raise TypeError('Logical false representation must be a string.')
764027
def setting(self, opt, val):
        """"""
        opt = opt.encode()
        if isinstance(val, basestring):
            fluid_settings_setstr(self.settings, opt, val)
        elif isinstance(val, int):
            fluid_settings_setint(self.settings, opt, val)
        elif isinstance(val, float):
            fluid_settings_setnum(self.settings, opt, val)
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)
4814
def set_value(self, string_value):
        
        value = self.validate_value(string_value)
        self._value[self._channel._selected] = value
238689
def setValue(self, newText):
        """"""
        self.text = newText
        self.cursorPosition = len(self.text)
        self._updateImage()
100220
public void setStringAttribute(String name, String value) {
		Attribute attribute = getAttributes().get(name);
		if (!(attribute instanceof StringAttribute)) {
			throw new IllegalStateException("Cannot set boolean value on attribute with different type, " +
					attribute.getClass().getName() + " setting value " + value);
		}
		((StringAttribute) attribute).setValue(value);
	}
785885
def set_domain(self, values):
        """"""
        _flattenedList = sorted(flatten(values))
        self.domain = tuple(_flattenedList[0] if d == 'min' else d for d in self.domain)
        self.domain = tuple(_flattenedList[-1] if d == 'max' else d for d in self.domain)