*
     * @param index the name of the index to scroll through
     * @param callback the function to apply to each search hit, returning true to continue or false to stop
     * @return the number of documents processed
     */
    public static long scroll(final String index, final Function<SearchHit, Boolean> callback) {

_2016-01-13_

This release commits to a stable 3.0 API. Read the 3.0.0-RC1 changes for advice
on upgrading from 2.x to 3.x.

 *  **The `Callback` interface now takes a `Call`**. This makes it easier to
    check if the call was canceled from within the callback. When migrating
    async calls to this new API, `Call` is now the first parameter for both
    `onResponse()` and `onFailure()`.

        ComponentUtil.register(new WebConfigBhv() {
            @Override
            public ListResultBean<WebConfig> selectList(final CBCall<WebConfigCB> cbLambda) {
                cbLambda.callback(cb);
                final ListResultBean<WebConfig> list = new ListResultBean<>();
                list.add((WebConfig) crawlingConfigHelper.getCrawlingConfig("W1"));

                // Verify parameters
                assertSame(ldapUser, user);
                assertEquals("dc=example,dc=com", baseDn);
                assertEquals("(uid=%s)", accountFilter);
                assertEquals("(memberOf=%s)", groupFilter);

                // Test callback
                String[] callbackRoles = new String[] { "role1", "role2" };

                return BASE64URL_DECODER.decode(base64String.trim());
            }
            throw e;
        }
    }

    /**
     * Processes the callback from OpenID Connect provider.
     *
     * @param request the HTTP servlet request
     * @param code the authorization code
     * @return the login credential
     */

  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**
   * Process the next event. This will result in a single call to [Callback.onEvent] *unless* the

package tests

import (
	"gorm.io/gorm"
	"gorm.io/gorm/callbacks"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"
)

type DummyDialector struct {
	TranslatedErr error
}

func (DummyDialector) Name() string {
	return "dummy"
}

func (DummyDialector) Initialize(db *gorm.DB) error {
	callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{

	return tx
}

// Update updates column with value using callbacks. Reference: https://gorm.io/docs/update.html#Update-Changed-Fields
func (db *DB) Update(column string, value interface{}) (tx *DB) {
	tx = db.getInstance()
	tx.Statement.Dest = map[string]interface{}{column: value}
	return tx.callbacks.Update().Execute(tx)
}

     * Uses the default buffer size and no output callback.
     *
     * @param process the system process to wrap
     */
    public JobProcess(final Process process) {
        this(process, InputStreamThread.MAX_BUFFER_SIZE, null);
    }

    /**
     * Constructs a new JobProcess with the specified process, buffer size, and output callback.
     *
     * @param process the system process to wrap

    }

  /**
   * A callback to be invoked each time the dispatcher becomes idle (when the number of running
   * calls returns to zero).
   *
   * Note: The time at which a [call][Call] is considered idle is different depending on whether it
   * was run [asynchronously][Call.enqueue] or [synchronously][Call.execute]. Asynchronous calls
   * become idle after the [onResponse][Callback.onResponse] or [onFailure][Callback.onFailure]