Set the properties of a single cell.

    .. note::
        This function is slow.
    .. deprecated:: 4.5
        Use :any:`tcod.map.Map.transparent` and :any:`tcod.map.Map.walkable`
        arrays to set these properties.
338932
def map_set_properties(
    m: tcod.map.Map, x: int, y: int, isTrans: bool, isWalk: bool
) -> None:
    
    lib.TCOD_map_set_properties(m.map_c, x, y, isTrans, isWalk)
542972
def _set_properties(self):
        """"""

        self.codetext_ctrl.SetToolTipString(_("Enter python code here."))
        self.apply_button.SetToolTipString(_("Apply changes to current macro"))
        self.splitter.SetBackgroundStyle(wx.BG_STYLE_COLOUR)
        self.result_ctrl.SetMinSize((10, 10))
808454
function setSuperType(s) {
  const ss = _.isArray(s) ? s : [s]
  this.superClasses = _.uniq(this.superClasses.concat(ss))
}
965599
function set_property(X, wid, prop, type, format, data, null_terminated, cb) {

    if (typeof null_terminated === 'function') {
        cb = null_terminated;
        null_terminated = undefined;
    }

    async.parallel(
        [
            function get_prop_atom(cb) {
                if (typeof prop === 'string') {
                    X.InternAtom(false, prop, cb);
                } else {
                    cb(undefined, prop);
                }
            },
            function get_type_atom(cb) {
                if (typeof type === 'string') {
                    X.InternAtom(false, type, cb);
                } else {
                    cb(undefined, type);
                }
            }
        ],
        function(err, results) {
            if (err) {
                if (cb) {
                    cb(err);
                }

                return;
            }


            _set_property(X, wid, results[0], results[1], format, data, null_terminated, cb);
        }
    );
}
253874
def set_property(self, key, value):
        
        self.properties[key] = value
        self.sync_properties()
1303203
public void setProperty(String strKey, Object objValue)
    {
        if (m_mapParams == null)
            m_mapParams = new HashMap<String,Object>();
        m_mapParams.put(strKey, objValue);
    }
80214
def properties(self, properties):
        """"""
        # We make sure that the dictionary is a NocaseDict object, and that the
        # property values are CIMProperty objects:
        # pylint: disable=attribute-defined-outside-init
        self._properties = NocaseDict()
        if properties:
            try:
                # This is used for iterables:
                iterator = properties.items()
            except AttributeError:
                # This is used for dictionaries:
                iterator = properties
            for item in iterator:
                if isinstance(item, CIMProperty):
                    key = item.name
                    value = item
                elif isinstance(item, tuple):
                    key, value = item
                else:
                    raise TypeError(
                        _format("Input object for properties has invalid item "
                                "in iterable: {0!A}", item))
                self.__setitem__(key, value)
551718
def map(self, func):
        
        for row in self.table:
            for i, cell in enumerate(row):
                row[i] = func(cell)
525389
@Override
	public void setXtalInfo(String spaceGroupString, float[] unitCell, double[][] ncsOperMatrixList) {
		// Now set the xtalographic information
		PDBCrystallographicInfo pci = new PDBCrystallographicInfo();
		SpaceGroup spaceGroup = SpaceGroup.parseSpaceGroup(spaceGroupString);
		pci.setSpaceGroup(spaceGroup);
		if (unitCell.length > 0) {
			CrystalCell cell = new CrystalCell(unitCell[0], unitCell[1],
					unitCell[2], unitCell[3], unitCell[4], unitCell[5]);
			pci.setCrystalCell(cell);
			structure.setCrystallographicInfo(pci);
		}

		pci.setNcsOperators(MmtfUtils.getNcsAsMatrix4d(ncsOperMatrixList));
	}
456363
def file_set_properties(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/setProperties' % object_id, input_params, always_retry=always_retry, **kwargs)
375873
def set_object(self, obj, properties):
        """"""
        self._objects.add(obj)
        properties = set(properties)
        self._properties |= properties
        pairs = self._pairs
        for p in self._properties:
            if p in properties:
                pairs.add((obj, p))
            else:
                pairs.discard((obj, p))
878724
private void setProperties(Object object, UniqueId uniqueId, ByteBuf byteBuf) {
        ByteArrayReader reader = new ByteArrayReader(byteBuf);

        while(reader.available()) {
            int id = reader.readInt();
            UnsafeSetOp op = uniqueId.getUnsafeSetOp(id);
            Object value;
            int size;
            ArrayList<Object> list = new ArrayList<>();
            HashSet<Object> set = new HashSet<>();
            switch (op.getType()) {
                case SCHEMA_ID:
                    int length = reader.readInt();
                    value = reader.readString(length);
                    op.set(object, value);
                    break;
                case BYTE:
                    byte byteValue = (byte) reader.readByte();
                    op.set(object, byteValue);
                    break;
                case SHORT:
                    short shortVvalue = (short) reader.readShort();
                    op.set(object, shortVvalue);
                    break;
                case INTEGER:
                    int intValue = reader.readInt();
                    op.set(object, intValue);
                    break;
                case LONG:
                    long longValue = reader.readLong();
                    op.set(object, longValue);
                    break;
                case FLOAT:
                    float floatValue = reader.readFloat();
                    op.set(object, floatValue);
                    break;
                case DOUBLE:
                    double doubleValue = reader.readDouble();
                    op.set(object, doubleValue);
                    break;
                case STRING:
                    length = reader.readInt();
                    value = reader.readString(length);
                    op.set(object, value);
                    break;
                case BOOLEAN:
                    value = reader.readBoolean();
                    op.set(object, value);
                    break;
                case OBJECT:
                    length = reader.readInt();
                    value = conversion.convert(reader.readString(length), op.getObjectClass());
                    op.set(object, value);
                    break;
                case BYTE_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readByte());
                    }
                    op.set(object, list);
                    break;
                case SHORT_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readShort());
                    }
                    op.set(object, list);
                    break;
                case INTEGER_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readInt());
                    }
                    op.set(object, list);
                    break;
                case LONG_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readLong());
                    }
                    op.set(object, list);
                    break;
                case FLOAT_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readFloat());
                    }
                    op.set(object, list);
                    break;
                case DOUBLE_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readDouble());
                    }
                    op.set(object, list);
                    break;
                case STRING_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        length = reader.readInt();
                        list.add(reader.readString(length));
                    }
                    op.set(object, list);
                    break;
                case BOOLEAN_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        list.add(reader.readBoolean());
                    }
                    op.set(object, list);
                    break;
                case OBJECT_LIST:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        length = reader.readInt();
                        String stringValue = reader.readString(length);
                        value = conversion.convert(stringValue, op.getObjectClass());
                        list.add(value);
                    }
                    op.set(object, list);
                    break;
                case BYTE_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readByte());
                    }
                    op.set(object, set);
                    break;
                case SHORT_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readShort());
                    }
                    op.set(object, set);
                    break;
                case INTEGER_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readInt());
                    }
                    op.set(object, set);
                    break;
                case LONG_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readLong());
                    }
                    op.set(object, set);
                    break;
                case FLOAT_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readFloat());
                    }
                    op.set(object, set);
                    break;
                case DOUBLE_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readDouble());
                    }
                    op.set(object, set);
                    break;
                case STRING_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        length = reader.readInt();
                        set.add(reader.readString(length));
                    }
                    op.set(object, set);
                    break;
                case BOOLEAN_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        set.add(reader.readBoolean());
                    }
                    op.set(object, set);
                    break;
                case OBJECT_SET:
                    size = reader.readInt();
                    for (int i = 0; i < size; i++) {
                        length = reader.readInt();
                        String stringValue = reader.readString(length);
                        value = conversion.convert(stringValue, op.getObjectClass());
                        set.add(value);
                    }
                    op.set(object, set);
                    break;
                case REFERENCE_HOLDER:
                    Map<String, List<String>> references = new HashMap<>();
                    ConfigReferenceHolder holder = new ConfigReferenceHolder(references);
                    int numProperties = reader.readInt();
                    for (int i = 0; i < numProperties; i++) {
                        length = reader.readInt();
                        String property = reader.readString(length);
                        int numInstances = reader.readInt();
                        ArrayList<String> instances = new ArrayList<>();
                        for (int j = 0; j < numInstances; j++) {
                            length = reader.readInt();
                            instances.add(reader.readString(length));
                        }
                        references.put(property, instances);
                    }
                    op.set(object, holder);
                    break;
            }
        }
    }
376370
def set_generic_keys(self, properties, exclude_list):
        

        generic_keys = set(properties.keys()) - set(exclude_list)
        for generic_key in generic_keys:
            self.__setattr__(
                self._convert_to_snake_case(generic_key),
                properties[generic_key],
            )
576956
function setProperty(target, options) {
	if (defineProperty && options.name === '__proto__') {
		defineProperty(target, options.name, {
			enumerable: true,
			configurable: true,
			value: options.newValue,
			writable: true
		});
	} else {
		target[options.name] = options.newValue;
	}
}
614701
public void setProperty(Object object, Object newValue) {
        MetaMethod setter = getSetter();
        if (setter == null) {
            if (field != null && !Modifier.isFinal(field.getModifiers())) {
                field.setProperty(object, newValue);
                return;
            }
            throw new GroovyRuntimeException("Cannot set read-only property: " + name);
        }
        newValue = DefaultTypeTransformation.castToType(newValue, getType());
        setter.invoke(object, new Object[]{newValue});
    }
221097
def set_property(self, **kwargs):
        
        if not isinstance(self._value, nparray.ndarray):
            raise ValueError("value is not a nparray object")

        for property, value in kwargs.items():
            setattr(self._value, property, value)
732609
def _set_properties(self):
        """"""

        title = _("CSV Import: {filepath}").format(filepath=self.csvfilename)
        self.SetTitle(title)
        self.SetSize((600, 600))

        for button in [self.button_cancel, self.button_ok]:
            button.SetMinSize((80, 28))