forked from TrueCloudLab/restic
Vendor dependencies for GCS
This commit is contained in:
Alexander Neumann
parent
ba75a3884c
commit
8ca6a9a240
1228 changed files with 1769186 additions and 1 deletions
227
vendor/google.golang.org/api/iterator/examples_test.go
generated
vendored
Normal file
227
vendor/google.golang.org/api/iterator/examples_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
// 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
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue