module AWS::Core::Collection::WithNextToken

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

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