Get the DATA_SOURCE_HANDLE to the last modified or added record.
@param iHandleType The type of handle to use.
@return The handle of the last modified record.
771985
public Object getLastModified(int iHandleType) throws DBException, RemoteException
    {
        BaseTransport transport = this.createProxyTransport(GET_LAST_MODIFIED);
        transport.addParam(TYPE, iHandleType);
        Object strReturn = transport.sendMessageAndGetReply();
        Object objReturn = transport.convertReturnObject(strReturn);
        return this.checkDBException(objReturn);
    }
127753
public <T> ISyncHandler<? super T, ? extends ISyncableData> getHandler(T caller)
	{
		@SuppressWarnings("unchecked")
		ISyncHandler<? super T, ? extends ISyncableData> handler = (ISyncHandler<? super T, ? extends ISyncableData>) handlers.get(caller.getClass());
		if (handler == null)
		{
			MalisisCore.log.error("No ISyncHandler registered for type '{}'", caller.getClass());
			return null;
		}

		return handler;
	}
88341
@Override
    public String getNewTicketId(final String prefix) {
        val artifact = getSAMLArtifactType();
        return prefix + '-' + artifact.base64Encode();
    }
1143637
@SuppressWarnings("unchecked") public Class<T> getAnnotationHandledByThisHandler() {
		return (Class<T>) SpiLoadUtil.findAnnotationClass(getClass(), JavacAnnotationHandler.class);
	}
169814
public BaseDestinationHandler getDestinationHandler()
  {
    if (tc.isEntryEnabled())  
    {
      SibTr.entry(tc, "getDestinationHandler");
      SibTr.exit(tc, "getDestinationHandler", destinationHandler);
    }      
    return destinationHandler;
  }
125941
public int bookmarkToIndex(Object bookmark, int iHandleType)
    {
        int iTargetPosition;
        DataRecord thisBookmark = null;
        if (bookmark == null)
            return -1;
//+ Not found, look through the recordlist
        for (iTargetPosition = 0; iTargetPosition < m_iRecordListEnd; iTargetPosition += m_iRecordListStep)
        {
            thisBookmark = (DataRecord)this.elementAt(iTargetPosition);
            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
    }
819836
public int addNewBookmark(Object bookmark, int iHandleType)
    {
        if (bookmark == null)
            return -1;
        if (iHandleType != DBConstants.DATA_SOURCE_HANDLE)
        {   // The only thing that I know for sure is the bookmark is correct.
            DataRecord dataRecord = new DataRecord(null);
            dataRecord.setHandle(bookmark, iHandleType);
            bookmark = dataRecord;
        }

        int iIndexAdded = m_iEndOfFileIndex;
        if (m_iEndOfFileIndex == -1)
        { // End of file has not been reached - add this record to the "Add" buffer.
                // Add code here
        }
        else
        {
            // Update the record cached at this location
            m_gridBuffer.addElement(m_iEndOfFileIndex, bookmark, m_gridList);
            m_iEndOfFileIndex++;
        }
        return iIndexAdded;
    }
954565
public com.google.protobuf.ByteString
      getHandleBytes() {
    java.lang.Object ref = handle_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      handle_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
61189
public int getExpandedTypeID(int nodeHandle)
  {
    // %REVIEW% This _should_ only be null if someone asked the wrong DTM about the node...
    // which one would hope would never happen...
    int id=makeNodeIdentity(nodeHandle);
    if(id==NULL)
      return NULL;
    return _exptype(id);
  }
928389
public ChangedSizeHandler getChangedSizeHandler()
   {
      if (sizeHandler == null || sizeHandler instanceof ReadOnlyChangedSizeHandler)
      {
         return sizeHandler;
      }

      return new ReadOnlyChangedSizeHandler(sizeHandler.getNewSize(), sizeHandler.getPrevSize());
   }
627953
def GetHandle(self):
        ''' 
        '''
        win_id = self.winId()  # this returns either an int or voitptr

        if "%s"%type(win_id) == "<type 'PyCObject'>":  # PySide
            ### with PySide, self.winId() does not return an integer
            if sys.platform == "win32":
                ## Be careful, this hack is py27 specific
                ## does not work with python31 or higher
                ## since the PyCObject api was changed
                import ctypes
                ctypes.pythonapi.PyCObject_AsVoidPtr.restype = ctypes.c_void_p
                ctypes.pythonapi.PyCObject_AsVoidPtr.argtypes = [
                    ctypes.py_object]
                win_id = ctypes.pythonapi.PyCObject_AsVoidPtr(win_id)
        elif type(win_id) is not int:  #PyQt4 or 5
            ## below integer cast may be required because self.winId() can
            ## returns a sip.voitptr according to the PyQt version used
            ## as well as the python version
            win_id = int(win_id)
        return win_id
980731
public ControlHandler getControlHandler(
                                            SIBUuid8 sourceMEUuid)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "getControlHandler",
                        new Object[] { sourceMEUuid });

        ControlHandler msgHandler =
                        _pubsubOutputHandlers.get(sourceMEUuid);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getControlHandler", msgHandler);

        return msgHandler;
    }
233620
private static String getHandlerID(int transferMode,
				       int transferType,
				       int type) {
	String id = "";

	switch (transferMode) {
	case Session.MODE_STREAM:
	    id += "S-"; break;
	case GridFTPSession.MODE_EBLOCK:
	    id += "E-"; break;
	default:
	    throw new IllegalArgumentException("Mode not supported: " +
					       transferMode);
	}

	switch (transferType) {
	case Session.TYPE_IMAGE:
	    id += "I-"; break;
	case Session.TYPE_ASCII:
	    id += "A-"; break;
	default:
	    throw new IllegalArgumentException("Type not supported: " +
					       transferType);
	}

	switch (type) {
	case SOURCE:
	    id += "R"; break;
	case SINK:
	    id += "W"; break;
	default:
	    throw new IllegalArgumentException("Type not supported: " +
					       type);
	}

	if (id.equals("")) {
	    return null;
	}
	return id;
    }
56172
private byte[] getDataSourceMetadataWithHandleAsBytes(
      final Handle handle,
      final String dataSource
  )
  {
    return connector.lookupWithHandle(
        handle,
        dbTables.getDataSourceTable(),
        "dataSource",
        "commit_metadata_payload",
        dataSource
    );
  }
610911
private IAsyncResultHandler<IEngineResult> wrapResultHandler(final IAsyncResultHandler<IEngineResult> handler) {
        return (IAsyncResult<IEngineResult> result) -> {
            boolean doRecord = true;
            if (result.isError()) {
                recordErrorMetrics(result.getError());
            } else {
                IEngineResult engineResult = result.getResult();
                if (engineResult.isFailure()) {
                    recordFailureMetrics(engineResult.getPolicyFailure());
                } else {
                    recordSuccessMetrics(engineResult.getApiResponse());
                    doRecord = false; // don't record the metric now because we need to record # of bytes downloaded, which hasn't happened yet
                }
            }
            requestMetric.setRequestEnd(new Date());
            if (doRecord) {
                metrics.record(requestMetric);
            }
            handler.handle(result);
        };
    }
1107355
Integer getColJDBCDataType(int i) {
        return ValuePool.getInt(
            table.getColumn(i).getDataType().getJDBCTypeCode());
    }
660018
public Object getHandle(int iHandleType) throws DBException
    {
        Object bookmark = null;
        try   {
            if ((iHandleType & DBConstants.OBJECT_SOURCE_HANDLE) == 0)
                iHandleType = DBConstants.BOOKMARK_HANDLE;      // For JDBC, always use bookmark
            bookmark = super.getHandle(iHandleType);
        } catch (DBException ex)    {
            throw ex;
        }
        return bookmark;
    }