update a single byte.
488288
public void update(int b, ManifestEntryVerifier mev)
        throws IOException
    {
        if (b != -1) {
            if (parsingBlockOrSF) {
                baos.write(b);
            } else {
                mev.update((byte)b);
            }
        } else {
            processEntry(mev);
        }
    }
892931
protected void fillFromBytes(byte[] bytes)
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "fillFromBytes", com.ibm.ejs.util.Util.toHexString(bytes));

        _uuidHigh = (((long) bytes[0]) & 0xFF) << 56
                    | (((long) bytes[1]) & 0xFF) << 48
                    | (((long) bytes[2]) & 0xFF) << 40
                    | (((long) bytes[3]) & 0xFF) << 32
                    | (((long) bytes[4]) & 0xFF) << 24
                    | (((long) bytes[5]) & 0xFF) << 16
                    | (((long) bytes[6]) & 0xFF) << 8
                    | (((long) bytes[7]) & 0xFF) << 0;
        _uuidLow = (((long) bytes[8]) & 0xFF) << 56
                   | (((long) bytes[9]) & 0xFF) << 48
                   | (((long) bytes[10]) & 0xFF) << 40
                   | (((long) bytes[11]) & 0xFF) << 32
                   | (((long) bytes[12]) & 0xFF) << 24
                   | (((long) bytes[13]) & 0xFF) << 16
                   | (((long) bytes[14]) & 0xFF) << 8
                   | (((long) bytes[15]) & 0xFF) << 0;

        _cachedBytes = bytes;

        if (tc.isEntryEnabled())
            Tr.exit(tc, "fillFromBytes");
    }
1279115
def update_payload(self, fields=None):
        """"""
        payload = super(Subnet, self).update_payload(fields)
        if 'from_' in payload:
            payload['from'] = payload.pop('from_')
        return {u'subnet': payload}
1282777
public void putBytes(byte[] b, int boff, int len) {
        System.arraycopy(b, boff, _buffer, _offset, len);
        skip(len);
    }
1353318
def _update(self, data):
        """"""
        for k, v in six.iteritems(data):
            new_value = v
            if isinstance(v, dict):
                new_value = type(self)(v)
            elif isinstance(v, list):
                new_value = [(type(self)(e) if isinstance(e, dict) else e)
                             for e in v]
            setattr(self, k, new_value)
184384
def update(self, content):
        

        for byte in content:
            self._crc64 = (self._crc64 >> 8) ^ self._lookup_table[(self._crc64 & 0xff) ^ byte]
1319675
def __set_byte(self, byte, lineno):
        
        if byte < 0 or byte > 255:
            error(lineno, 'Invalid byte value %i' % byte)

        self.memory_bytes[self.org] = byte
        self.index += 1
986967
def update_payload(self, fields=None):
        """"""
        payload = super(Media, self).update_payload(fields)
        if 'path_' in payload:
            payload['path'] = payload.pop('path_')
        return {u'medium': payload}
1294299
def update(self, b):  # pylint: disable=method-hidden,invalid-name
        """"""
        with self.__lock:
            output = compress_update(self.__ctx, b)
            if self.__write:
                self.__write(self.__header)
                self.__header = None
                self.__write(output)
                self.update = self.__updateNextWrite
            else:
                header = self.__header
                self.__header = None
                self.update = self.__updateNextReturn
                return header + output
898488
def update(self, update_finished_cb):
        """"""
        if not self._update_finished_cb:
            self._update_finished_cb = update_finished_cb
            self.valid = False
            logger.debug('Updating content of memory {}'.format(self.id))
            # Start reading the header
            self.mem_handler.read(self, 0, 11)
244092
def replace_bytes(self, m):
        """"""

        esc = m.group(0)
        value = esc
        if m.group('special'):
            value = BACK_SLASH_TRANSLATION[esc]
        elif m.group('char'):
            try:
                value = chr(int(esc[2:], 16))
            except Exception:
                value = esc
        elif m.group('oct'):
            value = int(esc[1:], 8)
            if value > 255:
                value -= 256
            value = chr(value)
        return value.replace('\x00', '\n')
799037
def update(connection, force_download):
    """"""
    manager.database.update(
        connection=connection,
        force_download=force_download
    )
1086998
final public void Update (String s) {
		byte[] chars=s.getBytes();
		// Changed on 2004-04-10 due to getBytes(int,int,char[],byte) being deprecated
		//byte	chars[];
		//chars = new byte[s.length()];
		//s.getBytes(0, s.length(), chars, 0);

		Update(chars, chars.length);
	}
1231153
def _set_data(self, data):
        """"""
        if type(data) == bytearray:
            self._data = data
        elif type(data) == str:
            if sys.version_info < (3,):
                self._data = bytearray(data)
            else:
                self._data = bytearray(data.encode('ISO-8859-1'))
        elif type(data) == list or type(data) == tuple:
            self._data = bytearray(data)
        elif sys.version_info >= (3,) and type(data) == bytes:
            self._data = bytearray(data)
        else:
            raise Exception('Data must be bytearray, string, list or tuple,'
                            ' not {}'.format(type(data)))
1159852
def update(self):
        
        if self.var_info.bits_per_pixel == 1:
            b = self._img.tobytes("raw", "1;R")
            self.mmap[:len(b)] = b

        elif self.var_info.bits_per_pixel == 16:
            self.mmap[:] = self._img_to_rgb565_bytes()

        elif self.var_info.bits_per_pixel == 32:
            self.mmap[:] = self._img.convert("RGB").tobytes("raw", "XRGB")

        else:
            raise Exception("Not supported - platform %s with bits_per_pixel %s" %
                (self.platform, self.var_info.bits_per_pixel))
723851
def fileupdate(self, data):
        """"""

        self.name = data["name"]
        add = self.__additional
        add["filetype"] = "other"
        for filetype in ("book", "image", "video", "audio", "archive"):
            if filetype in data:
                add["filetype"] = filetype
                break
        if add["filetype"] in ("image", "video", "audio"):
            add["thumb"] = data.get("thumb", dict())
        # checksum is md5
        add["checksum"] = data["checksum"]
        add["expire_time"] = data["expires"] / 1000
        add["size"] = data["size"]
        add["info"] = data.get(add["filetype"], dict())
        add["uploader"] = data["user"]
        if self.room.admin:
            add["info"].update({"room": data.get("room")})
            add["info"].update({"uploader_ip": data.get("uploader_ip")})
        self.updated = True
433860
def update(self, key, value=None, dir=False, ttl=None, refresh=False,
               prev_value=None, prev_index=None, timeout=None):
        """"""
        return self.adapter.set(key, value, dir=dir, ttl=ttl, refresh=refresh,
                                prev_value=prev_value, prev_index=prev_index,
                                prev_exist=True, timeout=timeout)