module AWS::Core::Collection::WithNextToken

# Collection::WithNextToken

When making a request to list elements from one of these collections, the response may return a next token. This indicates there are more results than were returned. You can not control the number of elements returned with each response.

See {AWS::Core::Collection} for documentation on the available collection methods.

Protected Instance Methods

_each_batch(options = {}) { |batch| ... } click to toggle source
# File lib/aws/core/collection/with_next_token.rb, line 36
def _each_batch options = {}, &block

  limit = _extract_limit(options)

  next_token, skip_count = _extract_next_token(options)

  skipped = 0
  collected = 0

  begin

    offset = 0
    batch = []

    next_token = _each_item(next_token, options.dup) do |item|

      if skipped < skip_count
        skipped += 1
        next
      end

      if limit
        if collected < limit
          batch << item
          collected += 1
        else
          yield(batch)
          simulated_next_token = {}
          simulated_next_token[:token] = next_token if next_token
          simulated_next_token[:offset] = offset + skipped
          return simulated_next_token
        end
      else
        batch << item
        collected += 1
      end

      offset += 1

    end # _each_item

    yield(batch)

  end until next_token.nil? or (limit and limit == collected)

  next_token.nil? ? nil : { :token => next_token }

end
_extract_next_token(options) click to toggle source
Calls superclass method AWS::Core::Collection#_extract_next_token
# File lib/aws/core/collection/with_next_token.rb, line 85
def _extract_next_token options
  next_token = super
  case next_token
  when nil   then [nil, 0]
  when Hash  then [next_token[:token], next_token[:offset] || 0]
  else [next_token, 0]
  end
end