Return the getCursor for this consumer. This method is only called in the
case where messages are not classified by XD.
359335
public LockingCursor getDefaultGetCursor()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getDefaultGetCursor");

    LockingCursor cursor = consumerKeyFilter[0].getGetCursor();
    if(keyGroup != null)
      cursor = keyGroup.getDefaultGetCursor();
      
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getDefaultGetCursor", cursor);

    return cursor;
  }
1168029
@Override
   public CursorPosition getCursor()
   {
      if (settings.isAnsiConsole() && Config.isOSPOSIXCompatible())
      {
         try
         {
            StringBuilder col = new StringBuilder(4);
            StringBuilder row = new StringBuilder(4);
            out().print(ANSI.CURSOR_ROW);
            out().flush();
            boolean gotSep = false;
            // read the position
            int[] input = read();

            for (int i = 2; i < input.length - 1; i++)
            {
               if (input[i] == 59) // we got a ';' which is the separator
                  gotSep = true;
               else
               {
                  if (gotSep)
                     col.append((char) input[i]);
                  else
                     row.append((char) input[i]);
               }
            }
            return new CursorPosition(Integer.parseInt(row.toString()),
                     Integer.parseInt(col.toString()));
         }
         catch (Exception e)
         {
            if (settings.isLogging())
               logger.log(Level.SEVERE,
                        "Failed to find current row with ansi code: ", e);
            return new CursorPosition(-1, -1);
         }
      }
      return new CursorPosition(-1, -1);
   }
323542
def get_messages_since(self, cursor):
        
        results = []
        for msg in reversed(self.cache):
            if msg["id"] == cursor:
                break
            results.append(msg)
        results.reverse()
        return results
640269
def _cursor(self):
        """"""
        if self._conn is None:
            self._conn = sqlite3.connect(self.filename,
                                         check_same_thread=False)
        return self._conn.cursor()
925822
public SIMPIterator getQueuedMessageIterator()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getQueuedMessageIterator");

    List<ControlAdapter> messages = new ArrayList<ControlAdapter>();
    
    NonLockingCursor cursor = null;

    MessageItem referredItem = null;
    try
    {
      cursor =
        consumerDispatcher.getReferenceStream().newNonLockingCursor(null);
      cursor.allowUnavailableItems();
      MessageItemReference item = (MessageItemReference) cursor.next();
      while(item != null)
      {
        try
        {
          referredItem = (MessageItem)item.getReferredItem();
          if(referredItem != null)
          {
            // force the arrival time to be written to the jsMessage  
            referredItem.forceCurrentMEArrivalTimeToJsMessage();
          }
          
          // It's possible to get a null adapter back 
          ControlAdapter cAdapter = item.getControlAdapter();
          if(cAdapter != null)
            messages.add(cAdapter);
          
          item = (MessageItemReference) cursor.next();
        }
        catch (NotInMessageStore ef)
        {
          // No FFDC code needed
          // The message has already been consumed. Trace the exception but allow processing to continue.
          SibTr.exception(tc, ef);
        }
        catch (MessageStoreException e)
        {
          // FFDC
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.runtime.LocalSubscriptionControl.getQueuedMessageIterator",
            "1:275:1.36",
            this);
            

          SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
            new Object[] { "com.ibm.ws.sib.processor.runtime.LocalSubscriptionControl.getQueuedMessageIterator", 
                           "1:281:1.36", 
                           SIMPUtils.getStackTrace(e) });
        }        
      }      
    }
    catch (MessageStoreException e)
    {
      // FFDC
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.runtime.LocalSubscriptionControl.getQueuedMessageIterator",
        "1:292:1.36",
        this);
        

      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
        new Object[] { "com.ibm.ws.sib.processor.runtime.LocalSubscriptionControl.getQueuedMessageIterator", 
                       "1:298:1.36", 
                       SIMPUtils.getStackTrace(e) });
    }
    finally
    {
      if (cursor != null)
        cursor.finished();
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getQueuedMessageIterator");
      
    return new BasicSIMPIterator(messages.iterator());    
  }
940170
def get_cursor_pos(window):
    
    xpos_value = ctypes.c_double(0.0)
    xpos = ctypes.pointer(xpos_value)
    ypos_value = ctypes.c_double(0.0)
    ypos = ctypes.pointer(ypos_value)
    _glfw.glfwGetCursorPos(window, xpos, ypos)
    return xpos_value.value, ypos_value.value
1091158
def cursor(self,*args,**kwargs):
        
        d_out("Handle.cursor: Creating cursor..")
        if not self.open:
            raise Exception("Connection isn't open.")

        if 'cursor_factory' not in kwargs or kwargs['cursor_factory'] == None:
            kwargs["cursor_factory"] = Cursor
        callback = kwargs.pop('callback', None)
        cur = self.conn.cursor(*args,**kwargs)
        if callback:
            d_out('Handle.cursor() setting callback attrib {0}'.format(callback))
            cur.callback = callback
        return cur
460088
def __get(klass, account, client, params):
        
        resource = klass.RESOURCE_CONVERSATIONS.format(account_id=account.id)

        request = Request(
            account.client, klass.METHOD,
            resource, headers=klass.HEADERS, body=params)
        return Cursor(klass, request, init_with=[account])
915979
public T getTypedItem(int position) {
		try {
			return cursorToObject((Cursor) super.getItem(position));
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}
	}
470023
public final LockingCursor newLockingCursor(Filter filter, boolean jumpbackEnabled) throws PersistenceException, SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "newLockingCursor", new Object[] {filter, Boolean.valueOf(jumpbackEnabled)});

        AbstractItem item = getItem(); //225627
        int storageStrategy = item.getStorageStrategy(); // 225627
        long lockID = getMessageStoreImpl().getUniqueLockID(storageStrategy); // 225627
        PrioritizedCursor cursor = _references().newCursor(filter, lockID, jumpbackEnabled);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "newLockingCursor", cursor);
        return cursor;
    }
350356
def _restore_cursor(self):
        

        if len(self.cursor_save_stack):
            self.x, self.y = self.cursor_save_stack.pop()
262594
def get(self):
        '''
        inputHookFunc = c_void_p.from_address(self.inputHookPtr).value

        Cevent = INPUT_RECORD()
        count = DWORD(0)
        while 1:
            if inputHookFunc:
                call_function(inputHookFunc, ())
            status = self.ReadConsoleInputW(self.hin, 
                                        byref(Cevent), 1, byref(count))
            if status and count.value == 1:
                e = event(self, Cevent)
                return e
1103580
public <C> DbxDeltaC<C> getDeltaC(Collector<DbxDeltaC.Entry<DbxEntry>, C> collector, /*@Nullable*/String cursor)
        throws DbxException
    {
        return getDeltaC(collector, cursor, false);
    }
760793
private XSpellChecker GetSpellChecker(XLinguServiceManager mxLinguSvcMgr) {
    try {
      if (mxLinguSvcMgr != null) {
        return mxLinguSvcMgr.getSpellChecker();
      }
    } catch (Throwable t) {
      // If anything goes wrong, give the user a stack trace
      printMessage(t);
    }
    return null;
  }
1353877
public InputHandler getInputHandler()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getInputHandler");
      SibTr.exit(tc, "getInputHandler", inputHandler);
    }
    
    return inputHandler;
  }
380289
def cursor(self):
        
        if not self._active_cursor:
            self._active_cursor = self.model.find(self.query,
                                                  self.projection or None,
                                                  **self.options)
        return self._active_cursor
455857
def find_cursor(cursor_name, options)
        unless connection.is_a? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
          raise CursorsNotSupported, "#{connection.class} doesn't support cursors"
        end

        relation = merge(options.slice(:readonly, :references, :order, :limit, :joins, :group, :having, :offset, :select, :uniq))
        including = (relation.eager_load_values + relation.includes_values).uniq

        if including.present?
          join_dependency = construct_join_dependency(joins_values)

          aliases = join_dependency.aliases
          join_relation = select(aliases.columns)
          join_relation = apply_join_dependency(join_relation, join_dependency)

          ActiveRecord::PostgreSQLCursor.new(self, cursor_name, join_relation, join_dependency)
        else
          ActiveRecord::PostgreSQLCursor.new(self, cursor_name, relation)
        end
      end