Golang Reader.ReadBytes方法代码示例

func parseIndexEntry(r *bufio.Reader) (entry *IndexEntry, err error) {
	var binEntry indexEntry
	err = binary.Read(r, ord, &binEntry)
	if err != nil {
		return nil, err
	}

	// TODO: what if it is corrupted and too long?
	name, e := r.ReadBytes(token.NUL)
	if e != nil {
		return nil, e
	}
	name = util.TrimLastByte(name) // get rid of NUL

	// don't ask me how I figured this out after
	// a 14 hour workday
	leftOver := 7 - (len(name)+6)%8
	for j := 0; j < leftOver; j++ {
		// TODO: read the bytes at once somehow
		if _, err = r.ReadByte(); err != nil {
			return nil, err
		}
	}

	// record the entry
	return toIndexEntry(&binEntry, string(name)), nil
}

func writeTranslatedFile(context *FileContext, outFile *os.File) error {

	var sourceFile *os.File
	var sourceReader *bufio.Reader
	var line string
	var rawLine []byte
	var err error

	sourceFile, err = os.Open(context.fullPath)
	if err != nil {
		return err
	}
	defer sourceFile.Close()

	sourceReader = bufio.NewReader(sourceFile)

	for {
		rawLine, err = sourceReader.ReadBytes('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			return err
		}

		line = context.TranslateLine(string(rawLine))
		outFile.Write([]byte(line))
	}
	return nil
}

func Unpack(reader *bufio.Reader) ([]byte, error) {

	return reader.ReadBytes('\n')
	//if global.PackSplitType =="breakline" {

	//	return reader.ReadBytes('\n')
	//}

	lengthByte, _ := reader.Peek(4)
	lengthBuff := bytes.NewBuffer(lengthByte)
	var length int32
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil {
		return nil, err
	}
	fmt.Println("Get length :", length)
	if int32(reader.Buffered()) < length+4 {
		return nil, err
	}

	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return nil, err
	}
	return pack[4:], nil
}

func (p Delimiter) Process(r *bufio.Reader) ([]byte, error) {
	b, err := r.ReadBytes(p.Delim)
	if err != nil {
		return nil, err
	}
	return bytes.TrimSpace(b), nil
}

func readSimpleStr(r *bufio.Reader) (Resp, error) {
	b, err := r.ReadBytes(delimEnd)
	if err != nil {
		return Resp{}, err
	}
	return Resp{typ: SimpleStr, val: b[1 : len(b)-2]}, nil
}

func readNetString(r *bufio.Reader) ([]byte, error) {

	lenBytes, err := r.ReadBytes(':')
	if err != nil {
		return []byte{}, err
	}
	i, err := strconv.ParseInt(string(lenBytes[:len(lenBytes)-1]), 10, 0)
	dataLen := int(i) // 0 on error, safe to check this first
	if dataLen > MAXLEN {
		err = fmt.Errorf("Proposed Length > MAXLEN")
		return []byte{}, err
	}
	if err != nil {
		err = fmt.Errorf("Error Parsing Length %#v", lenBytes)
		return []byte{}, err
	}

	data = data[:dataLen]
	_, err = io.ReadFull(r, data)
	if err != nil {
		err = fmt.Errorf("Error reading data")
		return []byte{}, err
	}
	b, err := r.ReadByte()
	if err != nil || b != ',' {
		err = fmt.Errorf("Missing terminator")
		return []byte{}, err
	}

	return data, nil
}

func socksReadBytesUntil(r *bufio.Reader, end byte) ([]byte, error) {
	val, err := r.ReadBytes(end)
	if err != nil {
		return nil, err
	}
	return val, nil
}

func readPacket(br *bufio.Reader) ([]byte, error) {
	// Drop bytes preceding HEADER_BYTE
	_, err := br.ReadBytes(HEADER_BYTE)
	if err != nil {
		return nil, err
	}

	// Get packet length field
	packet := make([]byte, 4)
	read_bytes := 0
	for read_bytes < 4 {
		tmp := make([]byte, 4)
		nread, err := br.Read(tmp)
		if err != nil {
			return nil, err
		}
		copy(packet[read_bytes:], tmp[:nread])
		read_bytes += nread
	}
	pktlen := int(binary.BigEndian.Uint32(packet))

	// Get rest of packet
	packet = make([]byte, pktlen)
	read_bytes = 0
	for read_bytes < pktlen {
		tmp := make([]byte, pktlen)
		nread, err := br.Read(tmp)
		if err != nil {
			return nil, err
		}
		copy(packet[read_bytes:], tmp[:nread])
		read_bytes += nread
	}
	return packet, nil
}

func decodeIndex(rbuf *bufio.Reader, f *File) error {
	c, err := rbuf.Peek(len(blockIndex))
	if err != nil {
		if err == io.EOF {
			return nil
		}
		fmt.Printf("index-peek failed: %v\n", err)
		return err
	}
	if !bytes.Equal(c, blockIndex) {
		return nil
	}
	var ybuf []byte
	for {
		bline, err := rbuf.ReadBytes('\n')
		if err != nil {
			return err
		}
		ybuf = append(ybuf, bline...)
		if bytes.HasPrefix(bline, []byte("...")) {
			break
		}
	}
	err = yaml.Unmarshal(ybuf, &f.Index)
	return err
}

func parse(in *bufio.Reader) []Item {
	// Create the slice of items to be returned.  (This slice will be extended as necessary.)
	items := make([]Item, 0)

	// Parse each of the rules one by one.
	for {
		c, e := in.ReadByte()
		if e != nil || c == '}' {
			break
		}
		if c == ' ' || c == '\t' || c == '\n' || c == '\r' {
			continue
		}
		sel, e := in.ReadBytes('{')
		sel = bytes.Join([][]byte{[]byte{c}, sel}, []byte{})
		sel = sel[:len(sel)-1]
		sel = bytes.TrimSpace(sel)
		var t Item
		if c == '@' {
			t = parseQuery(sel[1:], in)
		} else {
			t = parseRule(sel, in)
		}
		if t != nil {
			items = append(items, t)
		}
	}

	return items
}

// returns err == io.EOF when we hit EOF without any further data
func (self *GraphiteMetric) Read(reader *bufio.Reader) error {
	buf, err := reader.ReadBytes('\n')
	str := strings.TrimSpace(string(buf))
	if err != nil {
		if err != io.EOF {
			return fmt.Errorf("connection closed uncleanly/broken: %s\n", err.Error())
		}
		if str == "" {
			return err
		}
		// else we got EOF but also data, so just try to process it as valid data
	}
	elements := strings.Fields(str)
	if len(elements) != 3 {
		return fmt.Errorf("Received '%s' which doesn't have three fields", str)
	}
	self.name = elements[0]
	self.floatValue, err = strconv.ParseFloat(elements[1], 64)
	if err != nil {
		return err
	}
	if i := int64(self.floatValue); float64(i) == self.floatValue {
		self.isInt = true
		self.integerValue = int64(self.floatValue)
	}
	timestamp, err := strconv.ParseUint(elements[2], 10, 32)
	if err != nil {
		return err
	}
	self.timestamp = int64(timestamp * 1000000)
	return nil
}

func main() {
	app := cli.NewApp()
	app.Name = "bbq"
	app.Usage = "Tool to help you BBQ"
	app.Commands = []cli.Command{
		{
			Name:      "item",
			ShortName: "i",
			Usage:     "items needed for bbq",
			Action: func(c *cli.Context) {
				file, err := os.Open("items.txt")
				if err != nil {
					log.Fatal(err)
				}
				var reader *bufio.Reader
				var line []byte
				reader = bufio.NewReader(file)
				for {
					if err == io.EOF {
						return
					}
					line, err = reader.ReadBytes('\n')
					print(string(line))
				}
			},
		},
	}

	app.Run(os.Args)
}

func recvResponse(r *bufio.Reader) (resp [][]byte, err error) {
	var s, arg []byte
	var argc int
	if s, err = r.ReadBytes(lfSign); err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return nil, err
	}

	switch s[0] {
	case intSign:
		resp = append(resp, s[:len(s)-2])
	case okSign, errSign:
		resp = append(resp, s[:len(s)-2])
	case multiBulkSign:
		// read argc
		if argc, err = strconv.Atoi(string(s[1 : len(s)-2])); err != nil {
			return nil, err
		}
		// read argv
		for i := 0; i < argc; i++ {
			if arg, err = readArgv(r); err != nil {
				return nil, err
			}
			resp = append(resp, arg)
		}
	default:
		fmt.Printf("%s", s)
		return nil, fmt.Errorf("Protocol Error: unexpected '%c'", s[0])
	}

	return resp, nil
}

func readArgv(r *bufio.Reader) (arg []byte, err error) {
	var s []byte
	if s, err = r.ReadBytes(lfSign); err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return nil, err
	}

	if s[0] == bulkSign {
		// read len
		var arglen, readlen int = 0, 0
		if arglen, err = strconv.Atoi(string(s[1 : len(s)-2])); err != nil {
			return nil, err
		}
		arg = make([]byte, arglen+2) // make sure to read "\r\n"
		if _, err := io.ReadFull(r, arg[readlen:]); err != nil {
			return nil, err
		}
		return arg[:len(arg)-2], nil
	} else if s[0] == intSign {
		return s[1 : len(s)-2], nil
	}

	return nil, errors.New("Protocol Error: expected $ or : but got " + string(s))
}

// Parse
func (c *Config) Parse(r *bufio.Reader) error {
	var section string = "defaults"
	for {
		l, err := r.ReadBytes('\n')
		if err == io.EOF {
			break
		} else if err != nil {
			return err
		}
		switch {
		case PatternEmpty.Match(l):
			continue
		case PatternComment.Match(l):
			continue
		case PatternSection.Match(l):
			m := PatternSection.FindSubmatch(l)
			section = string(bytes.TrimSpace(m[1]))
		case PatternOption.Match(l):
			m := PatternOption.FindSubmatch(l)
			c.Set(section, string(bytes.TrimSpace(m[1])), string(bytes.TrimSpace(m[2])))
		default:
			return &ConfigSyntaxError{string(l)}
		}
	}
	return nil
}