Get a unique key that describes the data in this record.
You can use this key to see if any of the data has changed since the message was last sent.
423341
public StringBuffer getMessageKey(StringBuffer sb)
    {
        if (sb == null)
            sb = new StringBuffer();
        if (m_messageDataDescChildren != null)
        {
            for (String strKey : m_messageDataDescChildren.keySet())
            {
                MessageDataDesc messageDataDesc = m_messageDataDescChildren.get(strKey);
                messageDataDesc.getMessageKey(sb);
            }
        }
        return sb;
    }
728174
def get(self, key, default=None, msg_if_none=None):
        
        out = getattr(self, key, default)

        if (out is None) and (msg_if_none is not None):
            raise ValueError(msg_if_none)

        return out
258392
def get_message(self):
        """"""

        result = ''
        if self._data_struct is not None:
            result = self._data_struct[KEY_MESSAGE]
        return result
1257874
private String _getUniqueKey()
	{
		StringBuilder b = new StringBuilder();
		b.append( service );
		b.append( "#" );
		b.append( method );
		if( params != null )
		{
			b.append( "#" );
			b.append( params.toString() );
		}

		return b.toString();
	}
802760
function getKeyDetailsString (key, redisConnection, data, next) {
  redisConnection.get(key, function (err, val) {
    if (err) {
      api.log('getRedisString: ' + err, 'error');
    }

    var details = {
      key: key,
      type: 'string',
      value: val
    };
    
    data.response.details = details;
    next();
  });
}
319725
def get_message_metadata(self, key: str) -> MaildirMessage:
        
        msg = MaildirMessage()
        subpath = self._lookup(key)
        subdir, name = os.path.split(subpath)
        msg.set_subdir(subdir)
        if self.colon in name:
            msg.set_info(name.rsplit(self.colon, 1)[-1])
        msg.set_date(os.path.getmtime(os.path.join(self._path, subpath)))
        return msg
790650
@Override
    public List<DataSlice> getPersistentData() throws PersistentDataEncodingException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getPersistentData");

        //Late store of the currentMEArrivalTimestamp.  If the message is never stored
        //in the message store, then there's no point taking the hit of storing the
        //timestamp in the message
        if (!arrivalTimeStored)
        {
            msg.setCurrentMEArrivalTimestamp(currentMEArrivalTimeStamp);
            arrivalTimeStored = true;
        }
        if (producerConnectionUuid != null)
        {
            //see defect 278038
            //Late store of the currentMEArrivalTimestamp.  If the message is never stored
            //in the message store, then there's no point taking the hit
            msg.setConnectionUuid(producerConnectionUuid);
        }

        List<DataSlice> data = null;

        try
        {
            // Prevent any concurrent JsMessage property changes that may cause
            // a serialization error
            synchronized (messageSyncUpdateLock)
            {
                //get the message's data in a list of DataSlice objects
                data = msg.flatten(getOwningMessageStore());
            }
        } catch (MessageEncodeFailedException e)
        {
            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.store.items.MessageItem.getPersistentData",
                                        "1:861:1.244.1.40",
                                        this);

            SibTr.exception(tc, e);
            SibTr.error(tc, "MESSAGE_CORRUPT_ERROR_CWSIP0262",
                        new Object[] {
                        SIMPUtils.getStackTrace(e)
                        });

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "getPersistentData", e);

            throw new PersistentDataEncodingException(
                            nls.getFormattedMessage(
                                                    "MESSAGE_CORRUPT_ERROR_CWSIP0262",
                                                    new Object[] {
                                                    e },
                                                    null),
                            e);
        } catch (MessageStoreException e)
        {
            // No FFDC code needed
            // We dont generate an FFDC here as this is sometimes acceptable behaviour - d542075

            SibTr.exception(tc, e);

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "getPersistentData", e);

            throw new PersistentDataEncodingException(e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getPersistentData");

        return data;
    }
657541
def save(self):
        
        record = self.record()
        if not record:
            logger.warning('No record has been defined for %s.' % self)
            return False
        
        if not self.signalsBlocked():
            self.aboutToSaveRecord.emit(record)
            self.aboutToSave.emit()
        
        values = self.saveValues()
        
        # ignore columns that are the same (fixes bugs in encrypted columns)
        check = values.copy()
        for column_name, value in check.items():
            try:
                equals = value == record.recordValue(column_name)
            except UnicodeWarning:
                equals = False
            
            if equals:
                check.pop(column_name)
        
        # check to see if nothing has changed
        if not check and record.isRecord():
            if not self.signalsBlocked():
                self.recordSaved.emit(record)
                self.saved.emit()
                self._saveSignalBlocked = False
            else:
                self._saveSignalBlocked = True
            
            if self.autoCommitOnSave():
                status, result = record.commit()
                if status == 'errored':
                    if 'db_error' in result:
                        msg = nativestring(result['db_error'])
                    else:
                        msg = 'An unknown database error has occurred.'
                    
                    QMessageBox.information(self,
                                            'Commit Error',
                                            msg)
                    return False
            return True
        
        # validate the modified values
        success, msg = record.validateValues(check)
        if ( not success ):
            QMessageBox.information(None, 'Could Not Save', msg)
            return False
        
        record.setRecordValues(**values)
        success, msg = record.validateRecord()
        if not success:
            QMessageBox.information(None, 'Could Not Save', msg)
            return False
        
        if ( self.autoCommitOnSave() ):
            result = record.commit()
            if 'errored' in result:
                QMessageBox.information(None, 'Could Not Save', msg)
                return False
        
        if ( not self.signalsBlocked() ):
            self.recordSaved.emit(record)
            self.saved.emit()
            self._saveSignalBlocked = False
        else:
            self._saveSignalBlocked = True
        
        return True
131571
protected Record getOrNullIfExpired(Record record, long now, boolean backup) {
        if (!isRecordStoreExpirable()) {
            return record;
        }
        if (record == null) {
            return null;
        }
        Data key = record.getKey();
        if (isLocked(key)) {
            return record;
        }
        if (!isExpired(record, now, backup)) {
            return record;
        }
        evict(key, backup);
        if (!backup) {
            doPostEvictionOperations(record);
        }
        return null;
    }
321480
String getShardKey(Message message) {
        return getShardKey(message.getTokenTime(), this.modShardPolicy.getMessageShard(message, metadata));
    }
1327654
function getKey(key, req) {
  var val = this._data[key];

  // got an expired key, delete it (active expiry)
  if(val && val.e && val.e <= Date.now()) {
    this.emit('expired', key);
    this.delKey(key, req);
    return undefined;
  }

  if(req) this.emit(val ? 'hit' : 'miss', key);

  if(typeof val === 'object') val.t = Date.now();

  return val ? val.v : undefined;
}
808041
public int handleGetRawRecordData(Rec record)
    {
        int iErrorCode = Constant.NORMAL_RETURN;
        record = this.setNodeIndex(RESET_INDEX, record);   // Being careful
        int iNodeCount = 1;
        if (this.getNodeType() == MessageRecordDesc.NON_UNIQUE_NODE)
            iNodeCount = this.getMessage().getNodeCount(this.getFullKey(null));
        for (int index = 1; index <= iNodeCount; index++)
        {
            if (this.getNodeType() == MessageRecordDesc.NON_UNIQUE_NODE)
                record = this.setNodeIndex(index, record);
            
            iErrorCode = super.handleGetRawRecordData(record);
            
            if (iErrorCode != Constant.NORMAL_RETURN)
                break;
        }
        if (this.getNodeType() == MessageRecordDesc.NON_UNIQUE_NODE)
            this.setNodeIndex(END_OF_NODES, record);
        return iErrorCode;
    }
161823
def get_number(self, key):
        
        storage = self.storage

        logger.debug("NUMBER before => %s" % storage.get(key, '-'))
        try:
            logger.debug("*** consecutive number lock acquire ***")
            lock.acquire()
            try:
                counter = storage[key]
                storage[key] = counter + 1
            except KeyError:
                storage[key] = 1
        finally:
            logger.debug("*** consecutive number lock release ***")
            self.storage._p_changed = True
            lock.release()

        logger.debug("NUMBER after => %s" % storage.get(key, '-'))
        return storage[key]
376075
def unique_id
      # check all_data instead of data, as we have to not reuse deleted key
      ids = Set.new(all_data.map { |e| e[:key] })
      id = 1
      loop do
        return id.to_s unless ids.include?(id.to_s)

        id += 1
      end
    end
323371
function(key, updates) {
      var that = this;

      if (!this._key || !key) {
        return Promise.reject(new Error('No unique key specified'));
      }

      return this.readByKey(key).then(function(doc) {
        return that._updateDoc(doc, updates);
      });
    }
307280
def _getPayload(self, record):
        

        try:
            # top level payload items
            d = record.__dict__
            pid = d.pop('process', 'nopid')
            tid = d.pop('thread', 'notid')

            payload = {
                k: v for (k, v) in d.items()
                if k in TOP_KEYS
            }

            # logging meta attributes
            payload['meta'] = {
                k: v for (k, v) in d.items()
                if k in META_KEYS
            }

            # everything else goes in details
            payload['details'] = {
                k: simple_json(v) for (k, v) in d.items()
                if k not in self.detail_ignore_set
            }

            payload['log'] = payload.pop('name', 'n/a')
            payload['level'] = payload.pop('levelname', 'n/a')
            payload['meta']['line'] = payload['meta'].pop('lineno', 'n/a')

            payload['message'] = record.getMessage()
            tb = self._getTraceback(record)
            if tb:
                payload['traceback'] = tb

        except Exception as e:
            payload = {
                'level': 'ERROR',
                'message': 'could not format',
                'exception': repr(e),
            }
        payload['pid'] = 'p-{}'.format(pid)
        payload['tid'] = 't-{}'.format(tid)
        return payload
396606
def _unique_key(job):
    
    return unique_key(testtype=str(job['testtype']),
                      buildtype=str(job['platform_option']),
                      platform=str(job['platform']))