Page Comparison

    /**
     * An option to use with {@link SearchApiOp} that specifies an opaque cookie
     * which is used by the resource providerconnector to
         *         track its position in the set of query results,
or          *         {@code null} if paged results are not requested (when the
         *         page size is 0), or if the first page of results is being
         *         requested (when the page size is non-zero).
         * @see #getPageSize()
  
      * @see #getPagedResultsOffset()
         */
    public static  final String getPagedResultsCookie() {
            return "1234";
        }OP_PAGED_RESULTS_COOKIE = "PAGED_RESULTS_COOKIE";
        /**
         * ReturnsAn the index within the result set of the first result which
         * should be returned. Paged results will be enabled if and only if the
         * page size is non-zero. If the parameter is not present or a value
         * less than 1 is specified then then the page following the previous
         * page returned will be returned. A value equal to or greater than 1
         * indicates that a specific page should be returned starting from the
 option to use with {@link SearchApiOp} that specifies the index within
       * position specified.
         *
         * @return The index within the result set of the first result which
         *         should be returned.
         * @see #getPageSize()
         * @see #getPagedResultsCookie()
         */
    public static final  int getPagedResultsOffset() {
            return 0;
String OP_PAGED_RESULTS_OFFSET = "PAGED_RESULTS_OFFSET";
       };
        /**
   
     * ReturnsAn theoption requestedto page results page size or {@code 0} if paged
         * results are not required. For all paged result requests other than
         * the initial request, a cookie should be provided with the query
         * request. Seeuse with {@link #getPagedResultsCookie()SearchApiOp} forthat morespecifies information.the requested
        *
         * @return The requested page results page size or.
{@code 0} if paged          **/
    public static final String results are not required.OP_PAGE_SIZE = "PAGE_SIZE";
          * @see #getPagedResultsCookie()
         * @see #getPagedResultsOffset()/**
           */ An option to      int getPageSize()use with {
            return 100;
        };
        /**
         * Returns@link SearchApiOp} that specifies the sort keys which should be used for ordering the JSON
         * resources returned by this query request. The returned list may be
         * modified if permitted by this query request.
   
     *
         * @return The sort keys which should be used for ordering the JSON
         *         resources returned by this query request (never {@code null}
         *         ).
         */
        List<SortKey> getSortKeys() {
            return Collections.emptyList();
        };
    }
    /**
     * ConnectorFacade calls this method once for each native query.
     *
     * @param query
     *            The native query to run. A value of null means
     *            "return every instance of the given object class".
     * @param handler
     *            Results should be returned to this handler
     * @param options {@link ConnectorObject} returned by
     *            Additional options that impact the way this operationsearch is runrequest.
     *            If the caller passes null, the framework will convert this
     *            into an empty set of options, so SPI need not guard against
     *            options being null.
     */
    public voidstatic executeQuery(QueryFilter query, QueryResultHandler handler, QueryOptions options);
}

        *for synchronization events (thatSyncDelta represent native changes that occurred)
     * immediately subsequent to the event from which the client obtained the
     * token.
     * <p>
     * A client that wants to read synchronization events "starting now" can
     * call {@link #getLatestSyncToken} and then pass that token into this
     * {@code sync()} method.
     *
     * @param filter
     *            The filter which used to select which ConnectorObject should
     *            be included. It includes the ObjectClass and the Token pair
     *            where token representing the last token from the previous
     *            sync. The {@code SyncResultsHandler} will return any number ofdelta: Collections.<SyncDelta>emptyList()) {
           *            {@linkplain org.identityconnectors.framework.common.objects.SyncDelta}
     *            objects, each of which contains a token. Should be
     *            {@code null} if this is the client's first call to the
     *            {@code sync()} method for this connector.
     * @param handler
     *      handler.handle(delta);
      The result handler. Must not be null.
     * @param options
     *            Options that affect the way this operation is run. If the
     *            caller passes {@code null}, the framework will convert this
     *            into an empty set of options, so an implementation need not
     *            guard against this being null.
  
  * @throws IllegalArgumentException      *             if {@code objectClass} or {@code handler} is null or if any
     *             argument is invalid.
     */
    public void sync(QueryFilter filter, SyncResultsHandler handler, OperationOptionsinstanceof optionsSyncTokenResultsHandler);   {
 /**      * Returns the token corresponding to the most recent synchronization event.
     * <p>
     * An application that wants to receive synchronization events
     * "starting now" --i.e., wants to receive only native changes that occur
     * after this method is called-- should call this method and then pass the
     * resulting token into {@linkplain #sync the sync() method}.
     *
     * @param objectClass
     *            the class of object for which to find the most recent
     *            synchronization event (if any). Must not be null.
     * @return A token if synchronization events exist; otherwise {@code null}.
     * @throws IllegalArgumentException
     *             if {@code objectClass} is null or is invalid.
     */ ((SyncTokenResultsHandler)handler).handleResult(lastToken);
       public SyncToken getLatestSyncToken(ObjectClass objectClass);
}