Set the current value for a channel.
4814
def set_value(self, string_value):
        
        value = self.validate_value(string_value)
        self._value[self._channel._selected] = value
275793
def set_estimate(self, bitrate: int, now_ms: int):
        
        self.current_bitrate = self._clamp_bitrate(bitrate, bitrate)
        self.current_bitrate_initialized = True
        self.last_change_ms = now_ms
815750
def join_channel(self, channel, key=None, tags=None):
        """"""
        params = [channel]
        if key:
            params.append(key)
        self.send('JOIN', params=params, tags=tags)
998955
def set(self, *path):
        
        self.path = [self.channel_name]
        self.path.extend(list(path))
1031729
public void setValue(final DeviceControllerChannel channel, final int value,
			final boolean nonVolatile) throws IOException {

		if (channel == null) {
			throw new RuntimeException("null-channel is not allowed. For devices "
					+ "knowing just one wiper Channel.A is mandatory for "
					+ "parameter 'channel'");
		}
		if (value < 0) {
			throw new RuntimeException("only positive values are allowed! Got value '"
					+ value + "' for writing to channel '"
					+ channel.name() + "'");
		}

		// choose proper memory address (see TABLE 4-1)
		byte memAddr = nonVolatile ?
				channel.getNonVolatileMemoryAddress()
				: channel.getVolatileMemoryAddress();

		// write the value to the device
		write(memAddr, value);

	}
1331128
def set_output(self, state, channel=2):
        """"""
        if state:
            self.instr.write(':OUTP{0} ON'.format(channel))
        else:
            self.instr.write(':OUTP{0} OFF'.format(channel))
1248082
public void setCurrentValue(final float currentValue) {
        this.currentValue = currentValue;
        initialValue = currentValue;
        targetValue = currentValue;
        transitionInProgress = false;
    }
926237
def set_override(self, newchannels):
        ''''''
        self.override = newchannels
        self.override_counter = 10
        self.send_rc_override()
1067718
def set_instrument(self, channel, instr, bank=0):
        """"""
        self.instr_event(channel, instr, bank)
        self.notify_listeners(self.MSG_INSTR, {'channel': int(channel),
            'instr': int(instr), 'bank': int(bank)})
825141
public void setChannelData(ChannelData data) throws ChannelException {
        this.channelData = data;
        setValues(data.getPropertyBag());
        if (tc.isDebugEnabled())
            outputConfigToTrace();
    }
551727
@Override
	public void setCurrentValue(final int value) throws IOException {

		// check boundaries
		final int newValue = getValueAccordingBoundaries(value);

		// set wipers according nonVolatileMode
		doWiperAction(new WiperAction() {

			@Override
			public void run(final boolean nonVolatile) throws IOException {

				controller.setValue(DeviceControllerChannel.valueOf(channel), newValue,
						nonVolatile);

			}

		});

		// set currentValue only if volatile-wiper is affected
		if (nonVolatileMode == MicrochipPotentiometerNonVolatileMode.NONVOLATILE_ONLY) {
			return;
		}

		// save current value
		currentValue = newValue;

	}
72974
def select(self, nowait=True, cb=None):
        '''
        
        '''
        nowait = nowait and self.allow_nowait() and not cb

        if not self._enabled:
            self._enabled = True
            self.channel.basic._msg_id = 0
            self.channel.basic._last_ack_id = 0
            args = Writer()
            args.write_bit(nowait)

            self.send_frame(MethodFrame(self.channel_id, 85, 10, args))

            if not nowait:
                self._select_cb.append(cb)
                self.channel.add_synchronous_cb(self._recv_select_ok)
1161132
public void setCurrent(String value)
    {
	current.replace(0, current.length(), value);
	cursor = 0;
	limit = current.length();
	limit_backward = 0;
	bra = cursor;
	ket = limit;
    }
1088437
public void setChannel(PrivateChannel channel) {
        if (this.channel != channel) {
            if (this.channel != null) {
                ((Cleanupable) this.channel).cleanup();
            }
            this.channel = channel;
        }
    }
103364
def set_channels(self, channels):
        
        for key in channels:
            self.set(key, channels[key])
491823
def _setCurrentRev(self, rev, branch='default'):
        """"""
        self.lastRev[branch] = str(rev)
        return self.setState('lastRev', self.lastRev)
179023
def update(self):
        """"""
        if self.single_channel:
            self.im.set_data(self.data[self.ind, :, :])
        else:
            self.im.set_data(self.data[self.ind, :, :, :])
        self.ax.set_ylabel('time frame %s' % self.ind)
        self.im.axes.figure.canvas.draw()