Given a binary payload d, update the appropriate payload fields of
    the message.
344352
def from_binary(self, d):
    
    p = MsgEphemerisGPSDepF._parser.parse(d)
    for n in self.__class__.__slots__:
      setattr(self, n, getattr(p, n))
90047
def payload_set(self, value):
        
        payload = saveJSON(value, pretty=False)
        super(APPDataMessage, self).payload_set(payload)
573106
def _update_data_out(self, data, dtype):
        """"""
        try:
            self.data_out.update({dtype: data})
        except AttributeError:
            self.data_out = {dtype: data}
1196810
def update_payload(self, fields=None):
        """"""
        payload = super(ConfigTemplate, self).update_payload(fields)
        if 'template_combinations' in payload:
            payload['template_combinations_attributes'] = payload.pop(
                'template_combinations')
        return {u'config_template': payload}
183977
def update_payload(self, fields=None):
        """"""
        org_payload = super(Organization, self).update_payload(fields)
        payload = {u'organization': org_payload}
        if 'redhat_repository_url' in org_payload:
            rh_repo_url = org_payload.pop('redhat_repository_url')
            payload['redhat_repository_url'] = rh_repo_url
        return payload
199692
def modify_data(self, message):
        
        assert message.arbitration_id == self.can_id, "You cannot modify the can identifier"
        self.message = message
        header = build_bcm_update_header(self.can_id_with_flags, self.flags)
        frame = build_can_frame(message)
        send_bcm(self.bcm_socket, header + frame)
1188933
def add_payload(self, payload):
        
        if self.payloads:
            self.payloads[-1].next_payload = payload._type
        self.payloads.append(payload)
244743
def update_deps( self ):
        """"""
        klass = self.__class__

        for name in klass._fields:
            self.update_deps_on_field( name )
        return
667547
def update(self, **kwds):
        
        result = self._client.tag.update(self, **kwds)
        self._replace_fields(result.get_fields())
899734
def update_identity(self):
        """"""

        fr = self.record

        d = fr.unpacked_contents

        d['identity'] = self._dataset.identity.ident_dict
        d['names'] = self._dataset.identity.names_dict

        fr.update_contents(msgpack.packb(d), 'application/msgpack')
379562
def update_Dim(self,name,value):
        '''
        
           
        '''
        oldVal=self._dimensions[name]
        self._dimensions[name] += value
        self.message(2, 'Updating dimension {0} (from {1} to {2})'.format(name,oldVal,self._dimensions[name]))
        
        #Update dimensions within all variables
        for p in self.par_list:
            if self.__dict__[p].__dict__.has_key('_dimensions'):
                for d in self.__dict__[p]._dimensions.keys():
                    self.__dict__[p]._dimensions.update({d:self._dimensions[d]})
916310
def update_payload(self, fields=None):
        """"""
        payload = super(JobTemplate, self).update_payload(fields)
        effective_user = payload.pop(u'effective_user', None)
        if effective_user:
            payload[u'ssh'] = {u'effective_user': effective_user}
        return {u'job_template': payload}
8928
def update_message(index, attributes, values_by_doc)
      message = Message.new

      message.append_string index
      message.append_array attributes

      message.append_int values_by_doc.length
      values_by_doc.each do |key,values|
        message.append_64bit_int key # document ID
        message.append_ints *values # array of new values (integers)
      end

      message.to_s
    end
1165247
def _update_Prxy(self):
        """"""
        self.Prxy = self.Frxy * self.Qxy
        _fill_diagonals(self.Prxy, self._diag_indices)
923200
protected void updateBytesRead() {
        if (log.isTraceEnabled()) {
            log.trace("updateBytesRead");
        }
        long bytesRead = getReadBytes();
        if (bytesRead >= nextBytesRead) {
            BytesRead sbr = new BytesRead((int) (bytesRead % Integer.MAX_VALUE));
            getChannel(2).write(sbr);
            nextBytesRead += bytesReadInterval;
        }
    }
551807
def AdjustDescriptor(self, fields):
    """"""

    for f in fields:
      if f.name == "args_rdf_name":
        f.name = "payload_type"

      if f.name == "args":
        f.name = "payload"

    return fields
421383
public void update(byte[] buf, int off, int len) throws SignatureException {
        if (RSAdata != null || digestAttr != null)
            messageDigest.update(buf, off, len);
        else
            sig.update(buf, off, len);
    }