227 lines
6.1 KiB
Go
227 lines
6.1 KiB
Go
// Copyright 2016 Google Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package iterator_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"html/template"
|
|
"log"
|
|
"math"
|
|
"net/http"
|
|
"sort"
|
|
"strconv"
|
|
|
|
"golang.org/x/net/context"
|
|
"google.golang.org/api/iterator"
|
|
)
|
|
|
|
var (
|
|
client *Client
|
|
ctx = context.Background()
|
|
)
|
|
|
|
var pageTemplate = template.Must(template.New("").Parse(`
|
|
<table>
|
|
{{range .Entries}}
|
|
<tr><td>{{.}}</td></tr>
|
|
{{end}}
|
|
</table>
|
|
{{with .Next}}
|
|
<a href="/entries?pageToken={{.}}">Next Page</a>
|
|
{{end}}
|
|
`))
|
|
|
|
// This example demonstrates how to use Pager to support
|
|
// pagination on a web site.
|
|
func Example_webHandler(w http.ResponseWriter, r *http.Request) {
|
|
const pageSize = 25
|
|
it := client.Items(ctx)
|
|
var items []int
|
|
pageToken, err := iterator.NewPager(it, pageSize, r.URL.Query().Get("pageToken")).NextPage(&items)
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("getting next page: %v", err), http.StatusInternalServerError)
|
|
}
|
|
data := struct {
|
|
Items []int
|
|
Next string
|
|
}{
|
|
items,
|
|
pageToken,
|
|
}
|
|
var buf bytes.Buffer
|
|
if err := pageTemplate.Execute(&buf, data); err != nil {
|
|
http.Error(w, fmt.Sprintf("executing page template: %v", err), http.StatusInternalServerError)
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
if _, err := buf.WriteTo(w); err != nil {
|
|
log.Printf("writing response: %v", err)
|
|
}
|
|
}
|
|
|
|
// This example demonstrates how to use a Pager to page through an iterator in a loop.
|
|
func Example_pageLoop() {
|
|
// Find all primes up to 42, in pages of size 5.
|
|
const max = 42
|
|
const pageSize = 5
|
|
p := iterator.NewPager(Primes(max), pageSize, "" /* start from the beginning */)
|
|
for page := 0; ; page++ {
|
|
var items []int
|
|
pageToken, err := p.NextPage(&items)
|
|
if err != nil {
|
|
log.Fatalf("Iterator paging failed: %v", err)
|
|
}
|
|
fmt.Printf("Page %d: %v\n", page, items)
|
|
if pageToken == "" {
|
|
break
|
|
}
|
|
}
|
|
// Output:
|
|
// Page 0: [2 3 5 7 11]
|
|
// Page 1: [13 17 19 23 29]
|
|
// Page 2: [31 37 41]
|
|
}
|
|
|
|
// The example demonstrates how to use a Pager to request a page from a given token.
|
|
func Example_pageToken() {
|
|
const pageSize = 5
|
|
const pageToken = "1337"
|
|
p := iterator.NewPager(Primes(0), pageSize, pageToken)
|
|
|
|
var items []int
|
|
nextPage, err := p.NextPage(&items)
|
|
if err != nil {
|
|
log.Fatalf("Iterator paging failed: %v", err)
|
|
}
|
|
fmt.Printf("Primes: %v\nToken: %q\n", items, nextPage)
|
|
// Output:
|
|
// Primes: [1361 1367 1373 1381 1399]
|
|
// Token: "1400"
|
|
}
|
|
|
|
// This example demonstrates how to get exactly the items in the buffer, without
|
|
// triggering an extra RPC.
|
|
func Example_serverPages() {
|
|
// The iterator returned by Primes has a default page size of 20, which means
|
|
// it will return all the primes in the range [2, 21).
|
|
it := Primes(0)
|
|
var items []int
|
|
for {
|
|
item, err := it.Next()
|
|
if err != nil && err != iterator.Done {
|
|
log.Fatal(err)
|
|
}
|
|
if err == iterator.Done {
|
|
break
|
|
}
|
|
items = append(items, item)
|
|
if it.PageInfo().Remaining() == 0 {
|
|
break
|
|
}
|
|
}
|
|
fmt.Println(items)
|
|
// Output:
|
|
// [2 3 5 7 11 13 17 19]
|
|
}
|
|
|
|
// Primes returns a iterator which returns a sequence of prime numbers.
|
|
// If non-zero, max specifies the maximum number which could possibly be
|
|
// returned.
|
|
func Primes(max int) *SieveIterator {
|
|
it := &SieveIterator{pos: 2, max: max}
|
|
it.pageInfo, it.nextFunc = iterator.NewPageInfo(
|
|
it.fetch,
|
|
func() int { return len(it.items) },
|
|
func() interface{} { b := it.items; it.items = nil; return b })
|
|
return it
|
|
}
|
|
|
|
// SieveIterator is an iterator that returns primes using the sieve of
|
|
// Eratosthenes. It is a demonstration of how an iterator might work.
|
|
// Internally, it uses "page size" as the number of ints to consider,
|
|
// and "page token" as the first number to consider (defaults to 2).
|
|
type SieveIterator struct {
|
|
pageInfo *iterator.PageInfo
|
|
nextFunc func() error
|
|
max int // The largest number to consider.
|
|
p []int // Primes in the range [2, pos).
|
|
pos int // Next number to consider when generating p.
|
|
items []int
|
|
}
|
|
|
|
// PageInfo returns a PageInfo, which supports pagination.
|
|
func (it *SieveIterator) PageInfo() *iterator.PageInfo { return it.pageInfo }
|
|
|
|
func (it *SieveIterator) fetch(pageSize int, pageToken string) (string, error) {
|
|
start := 2
|
|
if pageToken != "" {
|
|
s, err := strconv.Atoi(pageToken)
|
|
if err != nil || s < 2 {
|
|
return "", fmt.Errorf("invalid token %q", pageToken)
|
|
}
|
|
start = s
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 20 // Default page size.
|
|
}
|
|
|
|
// Make sure sufficient primes have been calculated.
|
|
it.calc(start + pageSize)
|
|
|
|
// Find the subslice of primes which match this page.
|
|
// Note that PageInfo requires that fetch does not remove any existing items,
|
|
// so we cannot assume that items is empty at this call.
|
|
items := it.p[sort.SearchInts(it.p, start):]
|
|
items = items[:sort.SearchInts(items, start+pageSize)]
|
|
it.items = append(it.items, items...)
|
|
|
|
if it.max > 0 && start+pageSize > it.max {
|
|
return "", nil // No more possible numbers to return.
|
|
}
|
|
|
|
return strconv.Itoa(start + pageSize), nil
|
|
}
|
|
|
|
// calc populates p with all primes up to, but not including, max.
|
|
func (it *SieveIterator) calc(max int) {
|
|
if it.max > 0 && max > it.max+1 { // it.max is an inclusive bounds, max is exclusive.
|
|
max = it.max + 1
|
|
}
|
|
outer:
|
|
for x := it.pos; x < max; x++ {
|
|
sqrt := int(math.Sqrt(float64(x)))
|
|
for _, p := range it.p {
|
|
switch {
|
|
case x%p == 0:
|
|
// Not a prime.
|
|
continue outer
|
|
case p > sqrt:
|
|
// Only need to check up to sqrt.
|
|
break
|
|
}
|
|
}
|
|
it.p = append(it.p, x)
|
|
}
|
|
it.pos = max
|
|
}
|
|
|
|
func (it *SieveIterator) Next() (int, error) {
|
|
if err := it.nextFunc(); err != nil {
|
|
return 0, err
|
|
}
|
|
item := it.items[0]
|
|
it.items = it.items[1:]
|
|
return item, nil
|
|
}
|