查询黑名单的成员列表
@param offset    查询结果的起始点
@param limit     查询结果集上限
@param callback  结果回调函数
336031
public void queryBlockedMembers(int offset, int limit, final AVIMConversationSimpleResultCallback callback) {
    if (null == callback) {
      return;
    } else if (offset < 0 || limit > 100) {
      callback.internalDone(null, new AVIMException(new IllegalArgumentException("offset/limit is illegal.")));
      return;
    }
    Map<String, Object> params = new HashMap<String, Object>();
    params.put(Conversation.QUERY_PARAM_LIMIT, limit);
    params.put(Conversation.QUERY_PARAM_OFFSET, offset);
    boolean ret = InternalConfiguration.getOperationTube().processMembers(this.client.getClientId(), this.conversationId,
            getType(), JSON.toJSONString(params), Conversation.AVIMOperation.CONVERSATION_BLOCKED_MEMBER_QUERY, callback);
    if (!ret) {
      callback.internalDone(null,
              new AVException(AVException.OPERATION_FORBIDDEN, "couldn't start service in background."));
    }
  }
733018
@com.fasterxml.jackson.annotation.JsonProperty("Limit")
    public void setLimit(String limit) {
        this.limit = limit;
    }
555024
public final void toLowerCase(final char[] buffer, final int offset, final int limit) {
    assert buffer.length >= limit;
    assert offset <= 0 && offset <= buffer.length;
    for (int i = offset; i < limit; ) {
      i += Character.toChars(
          Character.toLowerCase(
              codePointAt(buffer, i, limit)), buffer, i);
    }
  }
1013410
function (offset) {

            if (this.callbackID) {
                ariaCoreTimer.cancelCallback(this.callbackID);
                this.callbackID = null;
            }

            if (this._popup == null && this.ellipsesNeeded === true) {

                this.callbackID = ariaCoreTimer.addCallback({
                    fn : this._showPopup,
                    scope : this,
                    delay : 500,
                    args : offset
                });
            }
        }
76
public function addLimitOffset(int $limit, int $offset): void
    {
        if ($limit === 0 && $offset === 0) {
            return;
        }
        if ($limit === 0 && $offset <> 0) {
            return;
        }
        if ($offset === 0) {
            $this->statement .= ' LIMIT ' . $limit;
        } else {
            $this->statement .= sprintf(' LIMIT %d, %d', $offset, $limit);
        }
        $this->statement .= PHP_EOL;
    }
1218535
public static String nameFromOffset(long offset) {
        NumberFormat nf = NumberFormat.getInstance();
        nf.setMinimumIntegerDigits(20);
        nf.setMaximumFractionDigits(0);
        nf.setGroupingUsed(false);
        return nf.format(offset) + Log.FileSuffix;
    }
1168399
@Override
	public void registerExtenderCallbacks(final IBurpExtenderCallbacks callbacks) {

		// keep a reference to our callbacks object
		this.callbacks = callbacks;

		// obtain an extension helpers object
		helpers = callbacks.getHelpers();

		//get the output streams for info and error messages
		stdout = callbacks.getStdout();
		stderr = callbacks.getStderr();
		
		//put this into the local instance variable
		instance = this;

		//initialize the extension
		initialize();

		// set our extension name
		callbacks.setExtensionName(extensionName);

		callbacks.printOutput("Loaded " + extensionName);
	}
465682
private function appendLimitAndOffset(QueryBuilder $builder, $limit, $offset)
    {
        $limit = (int) $limit;
        $offset = (int) $offset;

        if ($limit > 0) {
            $builder->limit($limit);
        }

        if ($offset > 0) {
            $builder->skip($offset);
        }
        return $this;
    }
555848
function slice(int $offset, int $limit = null, bool $preserve_keys = false) {
        $data = $this->data;
        return (new self(\array_slice($data, $offset, $limit, $preserve_keys)));
    }
445796
function (context, callback) {
            var self = this,
                options,
                offset = 0,
                limit = 0,
                items,
                parameters = context.request.urlInfo.parameter;

            flow()
                .seq("collection", function (cb) {
                    self._findCollection(context, cb, false);
                })
                .seq("query", function (cb) {
                    var query = self.$restHandler.parseQueryForResource(parameters, self);
                    if (!query.query.sort) {
                        // use default sorting
                        var configuration = context.dataSource.getConfigurationForModelClass(this.vars.collection.$modelFactory);
                        if (configuration && configuration.$.defaultSorting) {
                            query.sort(configuration.$.defaultSorting);
                        }
                    }
                    self._modifyCollectionQuery(query, cb);
                })
                .seq("page", function (cb) {

                    this.vars.collection = this.vars.collection.query(this.vars.query);
                    var pageSize = context.dataSource.$.collectionPageSize;

                    if (parameters["limit"]) {
                        limit = parseInt(parameters["limit"]);
                    }

                    if (!limit || isNaN(limit)) {
                        limit = 100;
                    }

                    if (parameters["offset"]) {
                        offset = parseInt(parameters["offset"]);
                    }

                    // calculate page
                    limit = limit > pageSize ? pageSize : limit;

                    this.vars.collection.fetch({limit: limit, offset: offset}, cb);
                })
                .exec(function (err, results) {
                    if (!err) {
                        var response = context.response;

                        // switch context of collection to RestDataSource
                        var collection = results["collection"];
                        items = results["page"].$items;
                        // call compose
                        var processor = self.$restHandler.$restDataSource.getProcessorForCollection(collection);

                        items.forEach(function (item) {
                            var id = item.identifier();
                            if (id) {
                                self._fetchAllHrefsForModel(item, context);
                            }
                        });

                        var itemArray = processor.composeCollection(results["page"], "GET", null);

                        var res = {
                            count: results["collection"].$.$itemsCount,
                            limit: limit,
                            offset: offset,
                            results: itemArray
                        };

                        response.writeHead(200, "", {
                            'Content-Type': 'application/json; charset=utf-8'
                        });

                        response.write(JSON.stringify(res), 'utf8');
                        response.end();

                        callback(null);
                    } else {
                        if (!(err instanceof HttpError)) {
                            var statusCode = 404;
                            if (err === DataSource.ERROR.NOT_FOUND) {
                                statusCode = 404;
                            }
                            err = new HttpError(err, statusCode);
                        }
                        callback(err);
                    }


                });
        }
1263130
public function find(callable $callback, $keepKey = false, $offset = null, $limit = null)
    {
        return $this->bindNewInstance(Arr::find($this->convertArray($this), $callback, $keepKey, $offset, $limit));
    }
394613
public Query offset(final Integer offset) {
        this.offset = offset;

        // If we defined offset without limit, force a limit to handle MySQL and others gracefully.
        if (limit <= 0) {
            limit = Integer.MAX_VALUE - offset;
        }

        return this;
    }
1231621
private void _buildLimit(
                    final Limit limit,
                    final StringBuilder stmt
                    )
    {
        if (limit == null) {
            return;
        }

        stmt.append( _LIMIT_ );
        stmt.append( limit.getCount() );
        stmt.append( _OFFSET_ );
        stmt.append( limit.getOffset() );
    }
205616
public function limit($limit, $offset = 0)
    {
        $this->limit = $limit;
        $this->offset = $offset;

        return $this;
    }
301177
function limitBy (arr, n, offset) {
  offset = offset ? parseInt(offset, 10) : 0
  n = util.toNumber(n)
  return typeof n === 'number'
    ? arr.slice(offset, offset + n)
    : arr
}
264377
public function applyOffsetAndLimit(QueryBuilder $query, ?int $offset, ?int $limit): void
    {
        $query->setFirstResult($offset ?? 0);

        if (is_int($limit) && $limit > 0) {
            $query->setMaxResults($limit);
        }
    }
877132
@Override
    public void setCallback(SourceCallback callback) {
        try {
            mCallbackLock.lock();
            mCallback = callback;
            mCallbackChanged.signal();
        } finally {
            mCallbackLock.unlock();
        }
    }