Golang Reader.ReadLine方法代码示例

func ParseVirtualDJTracklist(bufReader *bufio.Reader) []Track {
	var list []Track

	for line, _, err := bufReader.ReadLine(); err != io.EOF; line, _, err = bufReader.ReadLine() {
		data := strings.SplitN(string(line), " : ", 2)
		trackdata := strings.SplitN(data[1], " - ", 2)
		if len(trackdata) != 2 {
			term.OutputError("Error parsing track " + string(data[1]))
			term.OutputMessage("Please enter an artist for this track: ")
			artist, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect artist entry.")
				os.Exit(2)
			}
			term.OutputMessage("Please enter a name for this track: ")
			track, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect track name entry.")
				os.Exit(2)
			}

			trackdata = []string{artist, track}
		}

		thistrack := new(Track)
		thistrack.Artist = trackdata[0]
		thistrack.Song = trackdata[1]

		list = append(list, *thistrack)
	}

	return list
}

func Grep(arg *GrepArg) {
	var f []byte
	var path = ""
	var ok bool
	var stdin *bufio.Reader

	if path, ok = arg.input.(string); ok {
		if fi, err := os.Stat(path); err == nil && fi.Size() == 0 {
			return
		}
		mf, err := mmap.Open(path)
		if err != nil {
			errorline(err.Error() + ": " + path)
			return
		}
		defer mf.Close()
		f = mf.Data()
		doGrep(path, f, arg)
	} else if in, ok := arg.input.(io.Reader); ok {
		stdin = bufio.NewReader(in)
		for {
			f, _, err := stdin.ReadLine()
			doGrep("stdin", f, arg)
			if err != nil {
				break
			}
		}
	}
}

func getBoardAndPrincess(reader *bufio.Reader) (Board, Princess) {
	board := Board{}
	princess := Princess{}

	y := 0

	for {
		line, isPrefix, err := reader.ReadLine()

		if err == io.EOF {
			break
		}

		handleError(err)
		handleLongLines(isPrefix)

		x := bytes.Index(line, []byte("p"))

		if x > -1 {
			// Found the princess!
			princess.X = x
			princess.Y = y
		}

		y++

		board = append(board, line)
	}

	return board, princess
}

func parseOrders(r *bufio.Reader) ([]*order, error) {
	lineno := 0
	var keys, actions []byte
	var o []*order
	var err error
	for err == nil {
		l, _, err := r.ReadLine()
		if err != nil {
			break
		}
		lineno++
		if len(l) == 0 || l[0] == COMMENT {
			continue
		}
		for l[len(l)-1] == LINECONTINUE {
			nl, _, err := r.ReadLine()
			if err != nil {
				return nil, ParseError(fmt.Sprintf("line %d -- %s", lineno, err.Error()))
			}
			l = append(l, bytes.TrimFunc(nl, unicode.IsSpace)...)
		}
		if l[0] != SPACE {
			keys = bytes.Join(bytes.Split(l, []byte{SPACE}), []byte(""))
		} else {
			actions = bytes.TrimFunc(l, unicode.IsSpace)
		}
		if keys != nil && actions != nil {
			o = append(o, neworder(keys, actions))
			keys = nil
			actions = nil
		}
	}
	return o, nil
}

//ReadBufferedLine is a function which wraps around the bufio.ReadLine method to
//return a full line of data. bufio.ReadLine might return an incomplete line
//(requiring multiple calls to bufio.ReadLine), while this function ensures that
//it will return the complete line. In case the provided buffer is not large
//enough, it will grow
func ReadBufferedLine(r *bufio.Reader, p *[]byte) (bool, error) {
	//declare variables used in next loop, initialize isPrefix as true
	var line []byte
	var isPrefix bool = true
	var err error

	for isPrefix {
		//read (partial) data
		line, isPrefix, err = r.ReadLine()

		if err != nil {
			//check if it the error is EOF
			if err == io.EOF {
				//store last data
				*p = append(*p, line...)
				return true, nil
			}

			return true, err
		}

		//append line to buffer
		*p = append(*p, line...)
	}

	return false, nil
}

// Streams the tokens within a text file.
func TokensFromFile(filename string, lowerCase bool, returnChars bool) (tokens []string) {
	var (
		bfr *bufio.Reader
		tks []string
	)
	tokens = make([]string, 0)
	// Open the file for reading.
	fh, err := os.Open(filename)
	if err != nil {
		log.Fatal(err)
	}
	defer fh.Close()
	// Read the lines of the file one at a time.
	bfr = bufio.NewReaderSize(fh, 1024*16)
	for line, isprefix, err := bfr.ReadLine(); err != io.EOF; {
		// Error handling.
		if err != nil {
			log.Fatal(err)
		}
		if isprefix {
			log.Fatal("Line too long for buffered reader.")
		}
		// Convert the bytes in the line to nice tokens.
		tks = TokenizeLine(string(line), lowerCase, returnChars)
		for _, tk := range tks {
			tokens = append(tokens, tk)
		}
		// Read from the file for the next iteration.
		line, isprefix, err = bfr.ReadLine()
	}
	return
}

func (h *Harvester) readline(reader *bufio.Reader) (*string, error) {
	var buffer bytes.Buffer
	for {
		segment, is_partial, err := reader.ReadLine()
		if err != nil {
			// TODO(sissel): Handle the error, check io.EOF?
			// TODO(sissel): if eof and line_complete is false, don't check rotation unless a very long time has passed
			if err == io.EOF {
				time.Sleep(1 * time.Second)
				continue
			} else {
				fmt.Println(err)
				return nil, err // TODO(sissel): don't do this
			}

			// TODO(sissel): At EOF, check rotation
			// TODO(sissel): if nothing to do, sleep
		}

		// TODO(sissel): if buffer exceeds a certain length, maybe report an error condition? chop it?
		buffer.Write(segment)

		if !is_partial {
			str := new(string)
			*str = buffer.String()
			return str, nil
		}
	} /* forever read chunks */

	return nil, nil
}

func genDataFromGenFile(ctx context.Context, genFile *bufio.Reader, evStore evstore.Connection) {
	chanInput := make(chan string, 1)
	for {
		s, _, err := genFile.ReadLine()
		if err == io.EOF {
			log.Println("EOF")
			break
		}
		if err != nil {
			log.Panicln(err)
		}
		go genData(ctx, string(s), chanInput)
	}
	log.Println("Waiting for Ctrl-C")
Loop:
	for {
		select {
		case <-ctx.Done():
			break Loop
		case msg := <-chanInput:
			log.Println(msg)
			evStore.Committer().SubmitEvent("", "scalar", msg)
		}
	}
}

//for write command
func write(filename string, numBytes int, seconds int, reader *bufio.Reader) string {
	buffer := ""
	total := 0
	//Case when user presses enters while entering file content
	for total < numBytes {
		curBytes, _, _ := reader.ReadLine()
		total += len(curBytes) + 2
		buffer += string(curBytes)
		buffer += "\r\n"
	}
	if len(buffer) >= 2 {
		buffer = buffer[0 : len(buffer)-2]
	}
	if len(buffer) != numBytes {
		return "ERR_CMD_ERR\r\n"
	}
	lock.Lock()
	contentMap[filename] = buffer
	if versionMap[filename] == 0 {
		//version starts from 1
		versionMap[filename] = 1
	} else {
		versionMap[filename] += 1
	}
	fileTimeMap[filename] = time.Now()
	//Assuming when user enters 0 as exptime, not to expire file
	if seconds == -1 || seconds == 0 {
		expiryMap[filename] = infiTime
	} else {
		expiryMap[filename] = time.Second * time.Duration(seconds)
	}
	version := strconv.Itoa(versionMap[filename])
	lock.Unlock()
	return "OK " + version + "\r\n"
}

//将socket请求内容 解析为一个MCRequest对象
func (req *MCRequest) Receive(r *bufio.Reader) error {
	line, _, err := r.ReadLine()
	if err != nil || len(line) == 0 {
		return io.EOF
	}

	params := strings.Fields(string(line))
	command := CommandCode(params[0])

	switch command {

	case SET, ADD, REPLACE:
		req.Opcode = command
		req.Key = params[1]
		req.Length, _ = strconv.Atoi(params[4])

		value := make([]byte, req.Length+2)
		io.ReadFull(r, value)

		req.Value = make([]byte, req.Length)
		copy(req.Value, value)
	case GET:
		req.Opcode = command
		req.Key = params[1]
		RunStats["cmd_get"].(*CounterStat).Increment(1)
	case STATS:
		req.Opcode = command
		req.Key = ""
	case DELETE:
		req.Opcode = command
		req.Key = params[1]
	}
	return err
}

func mustReadLine(r *bufio.Reader) ([]byte, error) {
	line, prefix, err := r.ReadLine()
	if prefix {
		panic("prefix")
	}
	return line, err
}

func ReadLines_FromReader(reader *bufio.Reader) (lines []string, err error) {
	var (
		part   []byte
		prefix bool
	)
	buffer := bytes.NewBuffer(make([]byte, 0))
	//Read line from file and append the line to the List
	for {
		if part, prefix, err = reader.ReadLine(); err != nil {
			break
		}

		buffer.Write(part)
		if !prefix {
			lines = append(lines, buffer.String())
			buffer.Reset()
		}
	}

	if err == io.EOF {
		err = nil
	}

	return
}

func Readln(r *bufio.Reader) (string, error) {
	// http://stackoverflow.com/a/12206584
	// http://stackoverflow.com/a/21124415
	// http://stackoverflow.com/a/16615559
	//
	// Example:
	//
	// ```
	// reader := bufio.NewReaderSize(fp, 128 * 1024)  // 128KB
	//
	// line, err := Readln(reader)
	// for err == nil {
	//     fmt.Println(line)
	//     line, err = Readln(reader)
	// }
	// ```

	var (
		isPrefix         bool  = true
		err              error = nil
		line, ln         []byte
		num_buffer_count = 0
	)
	for isPrefix && err == nil {
		line, isPrefix, err = r.ReadLine()
		ln = append(ln, line...)

		num_buffer_count += 1
		if num_buffer_count > 10 {
			err = errors.New("too long line")
			break
		}
	}
	return string(ln), err
}

func readLine(r *bufio.Reader) string {
	line, _, err := r.ReadLine()
	if err != nil {
		return ""
	}
	return string(line)
}

// Format the input and return the formatted data.
// If any error is encountered, no data will be returned.
func Format(in io.Reader) ([]byte, error) {
	var src *bufio.Reader
	var ok bool
	src, ok = in.(*bufio.Reader)
	if !ok {
		src = bufio.NewReader(in)
	}
	dst := &bytes.Buffer{}
	state := fstate{out: dst, defines: make(map[string]struct{})}
	for {
		data, _, err := src.ReadLine()
		if err == io.EOF {
			state.flush()
			break
		}
		if err != nil {
			return nil, err
		}
		err = state.addLine(data)
		if err != nil {
			return nil, err
		}
	}
	return dst.Bytes(), nil
}