1// Copyright 2013 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package bufio_test
6
7import (
8	"bufio"
9	"bytes"
10	"fmt"
11	"os"
12	"strconv"
13	"strings"
14)
15
16func ExampleWriter() {
17	w := bufio.NewWriter(os.Stdout)
18	fmt.Fprint(w, "Hello, ")
19	fmt.Fprint(w, "world!")
20	w.Flush() // Don't forget to flush!
21	// Output: Hello, world!
22}
23
24func ExampleWriter_AvailableBuffer() {
25	w := bufio.NewWriter(os.Stdout)
26	for _, i := range []int64{1, 2, 3, 4} {
27		b := w.AvailableBuffer()
28		b = strconv.AppendInt(b, i, 10)
29		b = append(b, ' ')
30		w.Write(b)
31	}
32	w.Flush()
33	// Output: 1 2 3 4
34}
35
36// The simplest use of a Scanner, to read standard input as a set of lines.
37func ExampleScanner_lines() {
38	scanner := bufio.NewScanner(os.Stdin)
39	for scanner.Scan() {
40		fmt.Println(scanner.Text()) // Println will add back the final '\n'
41	}
42	if err := scanner.Err(); err != nil {
43		fmt.Fprintln(os.Stderr, "reading standard input:", err)
44	}
45}
46
47// Return the most recent call to Scan as a []byte.
48func ExampleScanner_Bytes() {
49	scanner := bufio.NewScanner(strings.NewReader("gopher"))
50	for scanner.Scan() {
51		fmt.Println(len(scanner.Bytes()) == 6)
52	}
53	if err := scanner.Err(); err != nil {
54		fmt.Fprintln(os.Stderr, "shouldn't see an error scanning a string")
55	}
56	// Output:
57	// true
58}
59
60// Use a Scanner to implement a simple word-count utility by scanning the
61// input as a sequence of space-delimited tokens.
62func ExampleScanner_words() {
63	// An artificial input source.
64	const input = "Now is the winter of our discontent,\nMade glorious summer by this sun of York.\n"
65	scanner := bufio.NewScanner(strings.NewReader(input))
66	// Set the split function for the scanning operation.
67	scanner.Split(bufio.ScanWords)
68	// Count the words.
69	count := 0
70	for scanner.Scan() {
71		count++
72	}
73	if err := scanner.Err(); err != nil {
74		fmt.Fprintln(os.Stderr, "reading input:", err)
75	}
76	fmt.Printf("%d\n", count)
77	// Output: 15
78}
79
80// Use a Scanner with a custom split function (built by wrapping ScanWords) to validate
81// 32-bit decimal input.
82func ExampleScanner_custom() {
83	// An artificial input source.
84	const input = "1234 5678 1234567901234567890"
85	scanner := bufio.NewScanner(strings.NewReader(input))
86	// Create a custom split function by wrapping the existing ScanWords function.
87	split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
88		advance, token, err = bufio.ScanWords(data, atEOF)
89		if err == nil && token != nil {
90			_, err = strconv.ParseInt(string(token), 10, 32)
91		}
92		return
93	}
94	// Set the split function for the scanning operation.
95	scanner.Split(split)
96	// Validate the input
97	for scanner.Scan() {
98		fmt.Printf("%s\n", scanner.Text())
99	}
100
101	if err := scanner.Err(); err != nil {
102		fmt.Printf("Invalid input: %s", err)
103	}
104	// Output:
105	// 1234
106	// 5678
107	// Invalid input: strconv.ParseInt: parsing "1234567901234567890": value out of range
108}
109
110// Use a Scanner with a custom split function to parse a comma-separated
111// list with an empty final value.
112func ExampleScanner_emptyFinalToken() {
113	// Comma-separated list; last entry is empty.
114	const input = "1,2,3,4,"
115	scanner := bufio.NewScanner(strings.NewReader(input))
116	// Define a split function that separates on commas.
117	onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
118		for i := 0; i < len(data); i++ {
119			if data[i] == ',' {
120				return i + 1, data[:i], nil
121			}
122		}
123		if !atEOF {
124			return 0, nil, nil
125		}
126		// There is one final token to be delivered, which may be the empty string.
127		// Returning bufio.ErrFinalToken here tells Scan there are no more tokens after this
128		// but does not trigger an error to be returned from Scan itself.
129		return 0, data, bufio.ErrFinalToken
130	}
131	scanner.Split(onComma)
132	// Scan.
133	for scanner.Scan() {
134		fmt.Printf("%q ", scanner.Text())
135	}
136	if err := scanner.Err(); err != nil {
137		fmt.Fprintln(os.Stderr, "reading input:", err)
138	}
139	// Output: "1" "2" "3" "4" ""
140}
141
142// Use a Scanner with a custom split function to parse a comma-separated
143// list with an empty final value but stops at the token "STOP".
144func ExampleScanner_earlyStop() {
145	onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
146		i := bytes.IndexByte(data, ',')
147		if i == -1 {
148			if !atEOF {
149				return 0, nil, nil
150			}
151			// If we have reached the end, return the last token.
152			return 0, data, bufio.ErrFinalToken
153		}
154		// If the token is "STOP", stop the scanning and ignore the rest.
155		if string(data[:i]) == "STOP" {
156			return i + 1, nil, bufio.ErrFinalToken
157		}
158		// Otherwise, return the token before the comma.
159		return i + 1, data[:i], nil
160	}
161	const input = "1,2,STOP,4,"
162	scanner := bufio.NewScanner(strings.NewReader(input))
163	scanner.Split(onComma)
164	for scanner.Scan() {
165		fmt.Printf("Got a token %q\n", scanner.Text())
166	}
167	if err := scanner.Err(); err != nil {
168		fmt.Fprintln(os.Stderr, "reading input:", err)
169	}
170	// Output:
171	// Got a token "1"
172	// Got a token "2"
173}
174