Create the record message.
Override this to add information to the message.
@param bookmark The bookmark of the record that is selected.
@return The record message.
179271
public RecordMessage createMessage(Object bookmark)
    {
        int iRecordMessageType = DBConstants.SELECT_TYPE;
        RecordMessageHeader messageHeader = new RecordMessageHeader(this.getOwner(), bookmark, null, iRecordMessageType, null);
        RecordMessage message = new RecordMessage(messageHeader);
        message.put(RecordMessageHeader.UPDATE_ON_SELECT, new Boolean(m_bUpdateOnSelect));
        if (this.getRecordToSync() != null)
            message.put(RecordMessageHeader.RECORD_TO_UPDATE, this.getRecordToSync());
        return message;
    }
1200297
public FieldList setHandle(Object bookmark, int iHandleType) throws DBException
    {
        this.setCurrentRecord(this.getBaseRecord());
        Object[] rgobjEnabledFields = this.getBaseRecord().setEnableFieldListeners(false);
        try {
            Record record = (Record)super.setHandle(bookmark, iHandleType);
            if (record == null)
                return null;

            this.getBaseRecord().setEnableFieldListeners(rgobjEnabledFields);

            this.getBaseRecord().handleValidRecord(); // Display Fields
            record = this.moveToCurrentRecord(record);
            if (record != null) if (record != this.getBaseRecord())
                record.handleValidRecord(); // Display Fields

            return record;
        } catch (DBException ex)    {
            throw ex;
        } finally {
            this.getBaseRecord().setEnableFieldListeners(rgobjEnabledFields);
        }
    }
1247696
public BoxRequestsBookmark.GetBookmarkInfo getInfoRequest(final String id) {
        BoxRequestsBookmark.GetBookmarkInfo request = new BoxRequestsBookmark.GetBookmarkInfo(id, getBookmarkInfoUrl(id), mSession);
        return request;
    }
567069
def add_bookmark(self, time):
        
        if self.annot is None:  # remove if buttons are disabled
            msg = 'No score file loaded'
            lg.debug(msg)
            error_dialog = QErrorMessage()
            error_dialog.setWindowTitle('Error adding bookmark')
            error_dialog.showMessage(msg)
            error_dialog.exec()
            return

        answer = QInputDialog.getText(self, 'New Bookmark',
                                      'Enter bookmark\'s name')
        if answer[1]:
            name = answer[0]
            self.annot.add_bookmark(name, time)
            lg.info('Added Bookmark ' + name + 'at ' + str(time))

        self.update_annotations()
833816
def add_tags_to_bookmark(self, bookmark_id, tags):
        
        url = self._generate_url('bookmarks/{0}/tags'.format(bookmark_id))
        params = dict(tags=tags)
        return self.post(url, params)
488565
public SessionInfo popWaitlistSession(Object bookmark)
    {
    	Vector<SessionInfo> vector = m_htWaitLists.get(bookmark);
    	if (vector == null)
    		return null;
    	SessionInfo sessionInfo = vector.remove(0);
    	if (vector.size() == 0)
    		m_htWaitLists.remove(bookmark);
    	return sessionInfo;
    }
1271518
protected EventBuilder createEventBuilder(LogRecord record) {
        EventBuilder eventBuilder = new EventBuilder()
            .withSdkIntegration("java.util.logging")
            .withLevel(getLevel(record.getLevel()))
            .withTimestamp(new Date(record.getMillis()))
            .withLogger(record.getLoggerName());

        String message = record.getMessage();
        if (record.getResourceBundle() != null && record.getResourceBundle().containsKey(record.getMessage())) {
            message = record.getResourceBundle().getString(record.getMessage());
        }

        String topLevelMessage = message;
        if (record.getParameters() == null) {
            eventBuilder.withSentryInterface(new MessageInterface(message));
        } else {
            String formatted;
            List<String> parameters = formatMessageParameters(record.getParameters());
            try {
                formatted = formatMessage(message, record.getParameters());
                topLevelMessage = formatted; // write out formatted as Event's message key
            } catch (Exception e) {
                // local formatting failed, send message and parameters without formatted string
                formatted = null;
            }
            eventBuilder.withSentryInterface(new MessageInterface(message, parameters, formatted));
        }
        eventBuilder.withMessage(topLevelMessage);

        Throwable throwable = record.getThrown();
        if (throwable != null) {
            eventBuilder.withSentryInterface(new ExceptionInterface(throwable));
        }

        Map<String, String> mdc = MDC.getMDCAdapter().getCopyOfContextMap();
        if (mdc != null) {
            for (Map.Entry<String, String> mdcEntry : mdc.entrySet()) {
                if (Sentry.getStoredClient().getMdcTags().contains(mdcEntry.getKey())) {
                    eventBuilder.withTag(mdcEntry.getKey(), mdcEntry.getValue());
                } else {
                    eventBuilder.withExtra(mdcEntry.getKey(), mdcEntry.getValue());
                }
            }
        }

        eventBuilder.withExtra(THREAD_ID, record.getThreadID());

        return eventBuilder;
    }
971936
def bookmark_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/bookmarks.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
360365
public FieldList setHandle(Object bookmark, int iHandleType) throws DBException
    {
        Record recMain = this.getRecord();
        this.setCurrentTable(this.getNextTable());
        FieldList record = super.setHandle(bookmark, iHandleType);
        
        if (record == null)
        {   // Not found in the main table, try the other tables
            Iterator<BaseTable> iterator = this.getTables();
            while (iterator.hasNext())
            {
                BaseTable table = iterator.next();
                if ((table != null) && (table != this.getNextTable()))
                {
                    Record recAlt = table.getRecord();
                    record = recAlt.setHandle(bookmark, iHandleType);
                    if (record != null)
                    {
                        this.syncRecordToBase(recMain, recAlt, false);
                        this.setCurrentTable(table);
                        break;
                    }
                }
            }
        }
        return record;
    }
1075729
public RecordWriter<K,SAMRecordWritable> getRecordWriter(
            TaskAttemptContext ctx, Path out)
            throws IOException
    {
        if (this.header == null)
            throw new IOException(
                    "Can't create a RecordWriter without the SAM header");

        return new KeyIgnoringCRAMRecordWriter<K>(out, header, writeHeader, ctx);
    }
411325
def bookmark_create(endpoint_plus_path, bookmark_name):
    
    endpoint_id, path = endpoint_plus_path
    client = get_client()

    submit_data = {"endpoint_id": str(endpoint_id), "path": path, "name": bookmark_name}

    res = client.create_bookmark(submit_data)
    formatted_print(res, simple_text="Bookmark ID: {}".format(res["id"]))
1051310
public Rec updateRecord(Rec record, boolean bRefresh)
    {
        try {
            Object bookmark = null;
            if (record.getEditMode() == Constant.EDIT_IN_PROGRESS)
            {
                if (bRefresh)
                    bookmark = record.getTable().getHandle(0);
                record.getTable().set(record);
            }
            else if ((record.getEditMode() == Constant.EDIT_ADD) && (record.isModified()))
            {
                record.getTable().add(record);
                if (bRefresh)
                    bookmark = record.getTable().getLastModified(0);
            }
            if (bRefresh)
                if (bookmark != null)
                {
                    record.getTable().setHandle(bookmark, 0);
                    record.getTable().edit();
                }
        } catch (DBException ex) {
            ex.printStackTrace();
            if (record != null)
                if (record.getTask() != null)
                    record.getTask().setLastError(ex.getMessage());
            return null;
        }
        return record;
    }
90288
public BoxRequestsBookmark.AddBookmarkToCollection getAddToCollectionRequest(String bookmarkId, String collectionId) {
        BoxRequestsBookmark.AddBookmarkToCollection request = new BoxRequestsBookmark.AddBookmarkToCollection(bookmarkId, collectionId, getBookmarkInfoUrl(bookmarkId), mSession);
        return request;
    }
944893
public BoxRequestsBookmark.UpdateBookmark getMoveRequest(String id, String parentId) {
        BoxRequestsBookmark.UpdateBookmark request = new BoxRequestsBookmark.UpdateBookmark(id, getBookmarkInfoUrl(id), mSession);
        request.setParentId(parentId);
        return request;
    }
1006960
public static BookmarkablePageLink<String> newBookmarkablePageLink(final String linkId,
		final Class<? extends Page> pageClass, final String labelId, final String resourceModelKey,
		final Component component)
	{
		return newBookmarkablePageLink(linkId, pageClass, labelId, resourceModelKey, null,
			component);
	}
362062
public int findElement(Object bookmark, int iHandleType)
    {
        int iTargetPosition;
        Object thisBookmark = null;
        if (bookmark == null)
            return -1;
        boolean bDataRecordFormat = false;
        for (iTargetPosition = m_iCurrentRecordStart; iTargetPosition < m_iCurrentRecordEnd; iTargetPosition++)
        {
            thisBookmark = this.elementAt(iTargetPosition);
            if (iTargetPosition == m_iCurrentRecordStart)
                if (thisBookmark instanceof DataRecord)
                    bDataRecordFormat = true;
            if (bookmark.equals(thisBookmark))
                return iTargetPosition;
            else if (bDataRecordFormat)
                if (bookmark.equals(((DataRecord)thisBookmark).getHandle(iHandleType)))
                    return iTargetPosition;
        }
//+ Still not found, do a binary search through the recordlist for a matching key
        return -1;  // Not found
    }
1131806
public void reverseBookmark(Object bookmark, int iAreaDesc)
    {
        if (this.getKeyFields() == 1)   // Special case - single unique key;
        {
            BaseField field = this.getField(iAreaDesc);
            boolean[] rgbEnabled = field.setEnableListeners(false);
            field.setData(bookmark, DBConstants.DONT_DISPLAY, DBConstants.INIT_MOVE);
            field.setEnableListeners(rgbEnabled);
        }
        else
        {
            BaseBuffer buffer = (BaseBuffer)bookmark;
            if (buffer != null)
                buffer.resetPosition();
            this.reverseKeyBuffer(buffer, iAreaDesc);
        }
    }