Get the waitlist for this bookmark.
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;
    }
424671
public int bookmarkToIndex(Object bookmark, int iHandleType)
    {
        if (bookmark == null)
            return -1;
        int iTargetPosition = m_gridBuffer.bookmarkToIndex(bookmark, iHandleType);
        if (iTargetPosition == -1)
            iTargetPosition = m_gridList.bookmarkToIndex(bookmark, iHandleType);
        return iTargetPosition;   // Target position
    }
1089199
private WaitChecker getUrlWaitChecker(String imageConfigDesc,
                                          Properties projectProperties,
                                          WaitConfiguration wait) {
        String waitUrl = StrSubstitutor.replace(wait.getUrl(), projectProperties);
        WaitConfiguration.HttpConfiguration httpConfig = wait.getHttp();
        HttpPingChecker checker;
        if (httpConfig != null) {
            checker = new HttpPingChecker(waitUrl, httpConfig.getMethod(), httpConfig.getStatus(), httpConfig.isAllowAllHosts());
            log.info("%s: Waiting on url %s with method %s for status %s.",
                     imageConfigDesc, waitUrl, httpConfig.getMethod(), httpConfig.getStatus());
        } else {
            checker = new HttpPingChecker(waitUrl);
            log.info("%s: Waiting on url %s.", imageConfigDesc, waitUrl);
        }
        return checker;
    }
1282456
public void list(String line, DispatchCallback callback) {
    int index = 0;
    DatabaseConnections databaseConnections = sqlLine.getDatabaseConnections();
    sqlLine.info(
        sqlLine.loc("active-connections", databaseConnections.size()));

    for (DatabaseConnection databaseConnection : databaseConnections) {
      boolean closed;
      try {
        closed = databaseConnection.connection.isClosed();
      } catch (Exception e) {
        closed = true;
      }

      sqlLine.output(
          sqlLine.getColorBuffer()
              .pad(" #" + index++ + "", 5)
              .pad(closed ? sqlLine.loc("closed") : sqlLine.loc("open"), 9)
              .pad(databaseConnection.getNickname(), 20)
              .append(" " + databaseConnection.getUrl()));
    }

    callback.setToSuccess();
  }
267033
def get_ticker(self):
        
        self._log('get ticker')
        return self._rest_client.get(
            endpoint='/ticker',
            params={'book': self.name}
        )
51457
public SessionInfo waitForUnlockAndLock(Object bookmark, SessionInfo sessionInfo, int iTimeToWait)
    {
        Utility.getLogger().info("Wait for unlock: " + bookmark + ", Session: " + sessionInfo.m_iSessionID);
        try {
        	synchronized (sessionInfo)
        	{
                if (!this.containsKey(bookmark))
                    return null; // Was unlocked between sync calls
                this.getWaitlist(bookmark, true).add(sessionInfo);
        		sessionInfo.wait(iTimeToWait);  // Wait to be unlocked
        		// If the timeout is reached, The next line will return the session of the hog who has the lock
                return this.addLock(bookmark, sessionInfo); // Was unlocked between sync calls
        	}
        } catch (InterruptedException ex)  {
            ex.printStackTrace();   // Never
        }
        return null;	// Error
    }
680859
def get_next(self, query, **options):
        """"""
        iterator = EventsPageIterator(self.client, '/events', query, options)
        result = iterator.next()
        return (result, iterator.sync)
1281539
public int bookmarkToIndex(Object bookmark, int iHandleType)
    {
        DataRecord thisBookmark = null;
        if (bookmark == null)
            return -1;
        for (int iTargetPosition = m_iCurrentRecordStart; iTargetPosition < m_iCurrentRecordEnd; iTargetPosition++)
        {
            thisBookmark = (DataRecord)this.elementAt(iTargetPosition);
            if (thisBookmark != null)
                if (bookmark.equals(thisBookmark.getHandle(iHandleType)))
                    return iTargetPosition;
        }
//+ Still not found, do a binary search through the recordlist for a matching key
        return -1;  // Not found
    }
771118
def list(self, limit=None, offset=None):
        """"""
        uri = "/%s%s" % (self.uri_base, self._get_pagination_qs(limit, offset))
        return self._list(uri)
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
    }
507209
def load_bookmark(self, slot_num):
        """"""
        bookmarks = CONF.get('editor', 'bookmarks')
        if slot_num in bookmarks:
            filename, line_num, column = bookmarks[slot_num]
        else:
            return
        if not osp.isfile(filename):
            self.last_edit_cursor_pos = None
            return
        self.load(filename)
        editor = self.get_current_editor()
        if line_num < editor.document().lineCount():
            linelength = len(editor.document()
                             .findBlockByNumber(line_num).text())
            if column <= linelength:
                editor.go_to_line(line_num + 1, column)
            else:
                # Last column
                editor.go_to_line(line_num + 1, linelength)
305397
public function getSearchList()
    {
        if ($this->searchList === null) {
            $this->searchList = $this->app->make(SearchList::class, [$this->getStickyRequest()]);
        }

        return $this->searchList;
    }
96128
public List<BookmarkedConference> getBookmarkedConferences() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        retrieveBookmarks();
        return Collections.unmodifiableList(bookmarks.getBookmarkedConferences());
    }
481895
def get_bookmarks(self, time=None, chan=None):
        
        # get bookmarks inside window
        try:
            bookmarks = self.rater.find('bookmarks')
        except AttributeError:
            raise IndexError('You need to have at least one rater')

        mrks = []
        for m in bookmarks:

            bookmark_start = float(m.find('bookmark_start').text)
            bookmark_end = float(m.find('bookmark_end').text)
            bookmark_chan = m.find('bookmark_chan').text
            if bookmark_chan is None:  # xml doesn't store empty string
                bookmark_chan = ''

            if time is None:
                time_cond = True
            else:
                time_cond = (time[0] <= bookmark_end and
                             time[1] >= bookmark_start)

            if chan is None:
                chan_cond = True
            else:
                chan_cond = bookmark_chan == chan

            if time_cond and chan_cond:
                one_mrk = {'name': m.find('bookmark_name').text,
                           'start': bookmark_start,
                           'end': bookmark_end,
                           'chan': bookmark_chan.split(', '),  # always a list
                           }
                mrks.append(one_mrk)

        return mrks
1149780
function list(callback, limit, offset) {
  if(!util.isFunction(callback)) {
    throw new Error('callback must be a function');
  }

  var resource = this.coinjar.merchant.api_endpoint + '/v1/orders.json',
    order_url = this.coinjar.merchant.orders_endpoint + '/',
    query = {};

  if(limit) { query.limit = limit; }
  if(offset) { query.offset = offset; }

  request.get(resource)
    .auth(this.coinjar.merchant.uuid, this.coinjar.merchant.secret)
    .query(query)
    .end(function (response) {
      if(isResponseError(response, callback)) { return; }
      // build the payment page url for each order object
      var i = response.body.orders.length;
      while (i--) {
        response.body.orders[i].payment_page_url = order_url + response.body.orders[i].uuid;
      }
      return callback(null, response.body.orders);
    });
}
937031
def set_bookmark(self, slot_num):
        """"""
        if self.data:
            editor = self.get_current_editor()
            editor.add_bookmark(slot_num)
13993
@Override
	public  T listGetPrevious(final T currentElement) {

		Relation<T, T, OneStartpoint<T>, OneEndpoint<T>> prevRel = currentElement.getIncomingRelationship(getSiblingLinkType());
		if (prevRel != null) {

			return (T)prevRel.getSourceNode();
		}

		return null;
	}