Golang bytes.LastIndex函数代码示例

func parseLine(line []byte) logKv {
	m := bytes.LastIndex(line, startKey)
	if m < 1 {
		return nil
	}
	n := bytes.LastIndex(line, stopKey)
	if n < m {
		return nil
	}
	kv := make(logKv)

	sub := line[m+1 : n]
	items := bytes.Split(sub, kvSpace)

	for _, item := range items {
		x := bytes.Index(item, eqSign)
		if x < 1 {
			continue
		}
		key := string(item[:x])
		val := string(item[x+1:])
		kv[key] = val
	}

	return kv
}

// handle the socket request
func (this *Server) HandleRequest(conn net.Conn, d []byte) {
	// example: {"usr":"","pwd":"123"}>>Member.Login
	//	defer func(){
	//		if e := recover();e!= nil{
	//			Println(e)
	//			debug.PrintStack()
	//		}
	//	}()

	if len(d) < len(CmdOperateBytes)+len(cmdDot) {
		conn.Write(invalidBytes)
		return
	}

	i := bytes.LastIndex(d, CmdOperateBytes)
	di := bytes.LastIndex(d, cmdDot)

	if i != -1 && di != -1 {
		rd, err := this.handle(d[i+len(CmdOperateBytes):di],
			d[di+len(cmdDot):], d[:i])

		if err != nil {
			Println("[Server][ ERROR]: " + err.Error())
			conn.Write([]byte(err.Error()))
		} else {
			Println(fmt.Sprintf("[Server][Output]:%s", string(rd)))
			conn.Write(rd)
		}
	} else {
		conn.Write(invalidBytes)
	}
}

func ExampleLastIndex() {
	fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
	// Output:
	// 0
	// 3
	// -1
}

// Функция разбора входящих данных и формирования объектов HttpRequest
// Возвращаемый результат: сформированный запрос (при наличии), необработанные данные,
// успешность выполнения (если false - получен некорректный запрос)
func ParseOneReq(data []byte) (req *HttpRequest, unworked_data []byte, success bool) {
	unworked_data = data
	success = true

	endl := []byte(endline_str)                          // Конец строки
	req_identifier := []byte(http_version + endline_str) // Признак запроса (версия HTTP + символы конца строки)

	// Ищем заголовок
	p_req_id := bytes.Index(unworked_data, req_identifier)
	p_endl := -1
	if p_req_id >= 0 {
		p_endl = bytes.LastIndex(unworked_data[:p_req_id], endl)
	} else {
		p_endl = bytes.LastIndex(unworked_data, endl)
	}

	if p_endl >= 0 {
		// Обнаружен переход на следующую строку перед признаком запроса - косяк
		unworked_data = unworked_data[p_endl+len(endline_str):]
		success = false
		return
	} else if p_req_id >= 0 {
		// Найден признак запроса
		p_req_id += len(req_identifier)
		params := strings.Split(string(unworked_data[:p_req_id]), " ")
		unworked_data = unworked_data[p_req_id:]

		if len(params) != 3 {
			// Неверный заголовок
			success = false
			return
		} // if len(params) != 3

		req = &HttpRequest{Type: params[0], Host: params[1]}
	} else {
		// Не нашли ни признака запроса, ни перехода на следующую строку
		unworked_data = data
		return
	}

	// Формируем параметры и тело запроса
	var rr *req_resp
	rr, unworked_data, success = parse_one_req_resp(unworked_data)
	if rr != nil {
		req.req_resp = *rr
	} else {
		req = nil
		if success {
			unworked_data = data
		}
	}

	return
} // func ParseOneReq(data []byte) (req *HttpRequest, unworked_data []byte, success bool)

func shortText(t []byte) []byte {
	if t == nil {
		return nil
	}

	// Cut signature.
	i := bytes.LastIndex(t, sigDash)
	j := bytes.LastIndex(t, quote)
	if i > j && bytes.Count(t[i+1:], nl) <= 10 {
		t = t[:i+1]
	}

	// Cut trailing quoted text.
	for {
		rest, last := lastLine(t)
		trim := bytes.TrimSpace(last)
		if len(rest) < len(t) && (len(trim) == 0 || trim[0] == '>') {
			t = rest
			continue
		}
		break
	}

	// Cut 'On foo.*wrote:' line.
	rest, last := lastLine(t)
	if onwrote.Match(last) {
		t = rest
	}

	// Cut trailing blank lines.
	for {
		rest, last := lastLine(t)
		trim := bytes.TrimSpace(last)
		if len(rest) < len(t) && len(trim) == 0 {
			t = rest
			continue
		}
		break
	}

	// Cut signature again.
	i = bytes.LastIndex(t, sigDash)
	j = bytes.LastIndex(t, quote)
	if i > j && bytes.Count(t[i+1:], nl) <= 10 {
		t = t[:i+1]
	}

	return t
}

// TODO:
func (f *File) OffsetLine(ln, start int) (offset int, e error) {
	if start < 0 || start > len(f.b) {
		return 0, memfile.OutOfBounds
	}
	if ln == 0 {
		i := bytes.LastIndex(f.b[:start], []byte("\n"))
		return i + 1, nil
	}
	if ln < 0 {
		i := 0
		return bytes.LastIndexFunc(f.b[:start], func(r rune) bool {
			if r == '\n' {
				if i == ln {
					return true
				}
				i--
			}
			return false
		}) + 1, nil
	}
	i := 0
	va := bytes.IndexFunc(f.b[start:], func(r rune) bool {
		if r == '\n' {
			i++
			if i == ln {
				return true
			}
		}
		return false
	})
	if va != -1 {
		return va + start + 1, nil
	}
	return len(f.b), nil
}

// need access to the original query contents in order to print it out properly,
// unfortunately.
func formatPgErr(contents *[]byte, pgerr *pq.Error) string {
	pos, _ := strconv.Atoi(pgerr.Position)
	lineNo := bytes.Count((*contents)[:pos], []byte("\n")) + 1
	columnNo := pos - bytes.LastIndex((*contents)[:pos], []byte("\n")) - 1

	return fmt.Sprint("PGERROR: line ", lineNo, " pos ", columnNo, ": ", pgerr.Message, ". ", pgerr.Detail)
}

// FileGetLastLine reads the last line from a file.
// In case of a network file, the whole file is read.
// In case of a local file, the last 64kb are read,
// so if the last line is longer than 64kb it is not returned completely.
// The first optional timeout is used for network files only.
func FileGetLastLine(filenameOrURL string, timeout ...time.Duration) (line string, err error) {
	if strings.Index(filenameOrURL, "file://") == 0 {
		return FileGetLastLine(filenameOrURL[len("file://"):])
	}

	var data []byte

	if strings.Contains(filenameOrURL, "://") {
		data, err = FileGetBytes(filenameOrURL, timeout...)
		if err != nil {
			return "", err
		}
	} else {
		file, err := os.Open(filenameOrURL)
		if err != nil {
			return "", err
		}
		defer file.Close()
		info, err := file.Stat()
		if err != nil {
			return "", err
		}
		if start := info.Size() - 64*1024; start > 0 {
			file.Seek(start, os.SEEK_SET)
		}
		data, err = ioutil.ReadAll(file)
		if err != nil {
			return "", err
		}
	}

	pos := bytes.LastIndex(data, []byte{'\n'})
	return string(data[pos+1:]), nil
}

// FromBytes takes a byte slice corresponding to a MaxMind DB file and returns
// a Reader structure or an error.
func FromBytes(buffer []byte) (*Reader, error) {
	metadataStart := bytes.LastIndex(buffer, metadataStartMarker)

	if metadataStart == -1 {
		return nil, fmt.Errorf("error opening database file: invalid MaxMind DB file")
	}

	metadataStart += len(metadataStartMarker)
	metadataDecoder := decoder{buffer[metadataStart:]}

	var metadata Metadata

	rvMetdata := reflect.ValueOf(&metadata)
	_, err := metadataDecoder.decode(0, rvMetdata)
	if err != nil {
		return nil, err
	}

	searchTreeSize := metadata.NodeCount * metadata.RecordSize / 4
	decoder := decoder{
		buffer[searchTreeSize+dataSectionSeparatorSize : metadataStart-len(metadataStartMarker)],
	}

	reader := &Reader{
		buffer:    buffer,
		decoder:   decoder,
		Metadata:  metadata,
		ipv4Start: 0,
	}

	reader.ipv4Start, err = reader.startNode()

	return reader, err
}

// New returns a new Article by decoding it from the given io.Reader.
func New(r io.Reader) (*Article, error) {
	data, err := ioutil.ReadAll(r)
	if err != nil {
		return nil, err
	}
	article := &Article{}
	var text, props []byte
	// Find last empty line
	sep := bytes.LastIndex(data, propertySeparator)
	if sep >= 0 {
		text = data[:sep]
		props = data[sep:]
	} else {
		text = data
	}
	for _, v := range propertyRe.FindAllSubmatch(props, -1) {
		key := string(v[1])
		value := string(v[2])
		if value != "" && value[0] == '"' && value[len(value)-1] == '"' {
			val, err := strconv.Unquote(value)
			if err != nil {
				return nil, fmt.Errorf("error unquoting %q: %s", value, err)
			}
			value = val
		}
		if err := article.add(key, value, false); err != nil {
			return nil, fmt.Errorf("error setting key %q with value %q: %s", key, string(value), err)
		}
	}
	text = append(text, propertyRe.ReplaceAll(props, nil)...)
	article.Text = bytes.TrimSpace(text)
	return article, nil
}

// Valid returns true if token is a valid, unexpired token returned by Generate.
func validAtTime(token, key, userID string, now time.Time) bool {
	// Decode the token.
	data, err := base64.URLEncoding.DecodeString(token)
	if err != nil {
		return false
	}

	// Extract the issue time of the token.
	sep := bytes.LastIndex(data, []byte{':'})
	if sep < 0 {
		return false
	}
	nanos, err := strconv.ParseInt(string(data[sep+1:]), 10, 64)
	if err != nil {
		return false
	}
	issueTime := time.Unix(0, nanos)

	// Check that the token is not expired.
	if now.Sub(issueTime) >= timeout {
		return false
	}

	// Check that the token is not from the future.
	// Allow 1 minute grace period in case the token is being verified on a
	// machine whose clock is behind the machine that issued the token.
	if issueTime.After(now.Add(1 * time.Minute)) {
		return false
	}

	// Check that the token matches the expected value.
	expected := generateAtTime(key, userID, issueTime)
	return token == expected
}

func (l *lexer) lexOptionValueFunc(section, name string) lexStep {
	return func() (lexStep, error) {
		var partial bytes.Buffer

		for {
			line, err := l.toEOL()
			if err != nil {
				return nil, err
			}

			// lack of continuation means this value has been exhausted
			idx := bytes.LastIndex(line, []byte{'\\'})
			if idx == -1 {
				partial.Write(line)
				break
			}

			partial.Write(line[0:idx])
			partial.WriteRune(' ')
		}

		val := strings.TrimSpace(partial.String())
		l.optchan <- &UnitOption{Section: section, Name: name, Value: val}

		return l.lexNextSectionOrOptionFunc(section), nil
	}
}

func Unmarshall(ns []byte) ([]byte, error) {
	if ns == nil {
		return nil, errors.New("ns is nil")
	}
	colonPos := bytes.Index(ns, []byte(":"))
	if colonPos == -1 {
		return nil, ErrNoColon
	}
	nsLenBytes := ns[:colonPos]
	nsLen, err := strconv.Atoi(string(nsLenBytes))
	if err != nil {
		return nil, ErrNsLenBytesConv
	}
	commaPos := bytes.LastIndex(ns, []byte(","))
	if commaPos == -1 {
		return nil, ErrNoComma
	}
	if commaPos-1 == colonPos {
		return nil, errors.New("org is nil")
	}

	if nsLen == commaPos-colonPos-1 {
		return ns[colonPos+1 : commaPos], nil
	} else {
		return nil, ErrNsLenNotEqaulOrgLen
	}
}

//Main parse loop
func (blp *Bls) parseBinlogEvents(sendReply proto.SendBinlogResponse, binlogReader io.Reader) {
	// read over the stream and buffer up the transactions
	var err error
	var line []byte
	bigLine := make([]byte, 0, BINLOG_BLOCK_SIZE)
	lineReader := bufio.NewReaderSize(binlogReader, BINLOG_BLOCK_SIZE)
	readAhead := false
	var event *blsEventBuffer
	var delimIndex int

	for {
		line = line[:0]
		bigLine = bigLine[:0]
		line, err = blp.readBlsLine(lineReader, bigLine)
		if err != nil {
			if err == io.EOF {
				//end of stream
				blp.globalState.blsStats.parseStats.Add("EOFErrors."+blp.keyrangeTag, 1)
				panic(newBinlogServerError(fmt.Sprintf("EOF")))
			}
			panic(newBinlogServerError(fmt.Sprintf("ReadLine err: , %v", err)))
		}
		if len(line) == 0 {
			continue
		}

		if line[0] == '#' {
			//parse positional data
			line = bytes.TrimSpace(line)
			blp.currentLine = string(line)
			blp.parsePositionData(line)
		} else {
			//parse event data

			if readAhead {
				event.LogLine = append(event.LogLine, line...)
			} else {
				event = newBlsEventBuffer(blp.currentPosition, line)
			}

			delimIndex = bytes.LastIndex(event.LogLine, BINLOG_DELIMITER)
			if delimIndex != -1 {
				event.LogLine = event.LogLine[:delimIndex]
				readAhead = false
			} else {
				readAhead = true
				continue
			}

			event.LogLine = bytes.TrimSpace(event.LogLine)
			event.firstKw = string(bytes.ToLower(bytes.SplitN(event.LogLine, SPACE, 2)[0]))

			blp.currentLine = string(event.LogLine)

			//processes statements only for the dbname that it is subscribed to.
			blp.parseDbChange(event)
			blp.parseEventData(sendReply, event)
		}
	}
}

func (this *simpleSigner) bytesSplit(value []byte) ([]byte, []byte) {
	idx := bytes.LastIndex(value, this.options.Separator)
	if idx == -1 {
		return value, nil
	}
	return value[:idx], value[idx+len(this.options.Separator):]
}