Beispiel #1
0
func main() {
	newlist := strconv.AppendQuote(make([]byte, 0), "")
	fmt.Println(string(newlist))
	newlist = strconv.AppendQuote(make([]byte, 0), "abc")
	fmt.Println(string(newlist))
	newlist = strconv.AppendQuote(make([]byte, 0), "中文")
	fmt.Println(string(newlist))
	newlist = strconv.AppendQuote(make([]byte, 0), "    ") // \t
	fmt.Println(string(newlist))

}
Beispiel #2
0
// Add data in the following format:
// [dataId name="value" name2="value2"][dataId2 name="value"].
func addData(b []byte, data map[string]map[string]string) []byte {
	if len(data) == 0 {
		b = append(b, nilValueByte)
		return b
	}

	for _, dataID := range getSortedMapMapKeys(data) {
		params := data[dataID]

		b = append(b, dataStart)
		b = append(b, dataID...)

		// Add name and value in the following format: ` name="value"`
		for _, name := range getSortedMapKeys(params) {
			value := params[name]
			b = append(b, spaceByte)
			b = append(b, name...)
			b = append(b, equalByte)
			b = strconv.AppendQuote(b, value)
		}

		b = append(b, dataEnd)
	}

	return b
}
Beispiel #3
0
func ExampleAppendQuote() {
	b := []byte("quote:")
	b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
	fmt.Println(string(b))

	// Output:
	// quote:"\"Fran & Freddie's Diner\""
}
Beispiel #4
0
func (a *App) WriteAccessLog(req *Req, dur time.Duration) {
	if a.accessLog == nil {
		return
	}
	logEvery, _ := a.Cfg.GetInt("gop", "access_log_every", 0)
	if logEvery > 0 {
		a.suppressedAccessLogLines++
		if a.suppressedAccessLogLines < logEvery {
			a.Debug("Suppressing access log line [%d/%d]", a.suppressedAccessLogLines, logEvery)
			return
		}
	}
	a.suppressedAccessLogLines = 0

	// Copy an nginx-log access log
	/* ---
	   gaiadev.leedsdev.net 0.022 192.168.111.1 - - [05/Feb/2014:13:39:22 +0000] "GET /bby/sso/login?next_url=https%3A%2F%2Fgaiadev.leedsdev.net%2F HTTP/1.1" 302 0 "-" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:26.0) Gecko/20100101 Firefox/26.0"
	   --- */
	trimPort := func(s string) string {
		colonOffset := strings.IndexByte(s, ':')
		if colonOffset >= 0 {
			s = s[:colonOffset]
		}
		return s
	}
	quote := func(s string) string {
		return string(strconv.AppendQuote([]byte{}, s))
	}

	reqFirstLine := fmt.Sprintf("%s %s %s", req.R.Method, req.R.RequestURI, req.R.Proto)
	referrerLine := req.R.Referer()
	if referrerLine == "" {
		referrerLine = "-"
	}
	uaLine := req.R.Header.Get("User-Agent")
	if uaLine == "" {
		uaLine = "-"
	}
	hostname := a.Hostname()
	logLine := fmt.Sprintf("%s %.3f %s %s %s %s %s %d %d %s %s\n",
		hostname,
		dur.Seconds(),
		trimPort(req.RealRemoteIP),
		"-", // Ident <giggle>
		"-", // user
		//		req.startTime.Format("[02/Jan/2006:15:04:05 -0700]"),
		req.startTime.Format("["+time.RFC3339+"]"),
		quote(reqFirstLine),
		req.W.code,
		req.W.size,
		quote(referrerLine),
		quote(uaLine))
	_, err := req.app.accessLog.WriteString(logLine)
	if err != nil {
		a.Errorf("Failed to write to access log: %s", err.Error())
	}
}
Beispiel #5
0
func AppendTest() {
	//Append 系列函数将整数等转换为字符串后,添加到现有的字节数组中。
	str := make([]byte, 0, 100)
	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "abcdefg")
	str = strconv.AppendQuoteRune(str, '单')
	fmt.Println(string(str))
}
Beispiel #6
0
func main() {

	/*
		/Enter the Key to be Written
		/writtenKey : String
	*/
	writtenKey := inputData()
	fmt.Println("Input Key : ", writtenKey)

	/*
		/Enter the data to be Written
		/writtenData : String
	*/
	writtenData := inputData()
	fmt.Println("Input data : ", writtenData)

	/*
		/Search or Write of the Start Key
		/dbKey : []byte
	*/
	var dbKey []byte

	/*
		/DATABASE Open
	*/
	db := dbOpen()

	/*
		/Convert Key from  String to []byte
	*/
	dbKey = strconv.AppendQuote(dbKey, writtenKey)
	fmt.Println("dbKey is ", string(dbKey))

	/*
		/DATABASE Put
	*/
	err := dbPut(db, writtenData, dbKey)
	if err != 0 {
		fmt.Println("DB Put ERROR")
	}

	/*
		/DATABASE All Read
	*/
	dbAllRead(db, dbKey)
	//fmt.Println("key : ", string(dbKey))
	//fmt.Println("data : ", string(dbData))

	/*
		/DATABASE Close
	*/
	defer db.Close()
}
Beispiel #7
0
// keys returns the keys that associate a trid with a tag.
func keys(trid string, tag string) (tridKey, tagKey []byte) {
	quoted := strconv.AppendQuote(nil, tag)

	tridKey = make([]byte, len(trid)+len(quoted))
	copy(tridKey, trid)
	copy(tridKey[len(trid):], quoted)

	tagKey = make([]byte, len(quoted)+len(trid))
	copy(tagKey, quoted)
	copy(tagKey[len(quoted):], trid)

	return tridKey, tagKey
}
Beispiel #8
0
// fmt_q formats a string as a double-quoted, escaped Go string constant.
// If f.sharp is set a raw (backquoted) string may be returned instead
// if the string does not contain any control characters other than tab.
func (f *fmt) fmt_q(s string) {
	s = f.truncate(s)
	if f.sharp && strconv.CanBackquote(s) {
		f.padString("`" + s + "`")
		return
	}
	buf := f.intbuf[:0]
	if f.plus {
		f.pad(strconv.AppendQuoteToASCII(buf, s))
	} else {
		f.pad(strconv.AppendQuote(buf, s))
	}
}
Beispiel #9
0
func Teststrings() {

	//字符串s中是否包含substr,返回bool值
	fmt.Println(strings.Contains("seafood", "foo"))
	fmt.Println(strings.Contains("seafood", "bar"))
	fmt.Println(strings.Contains("seafood", ""))
	fmt.Println(strings.Contains("", ""))
	s := []string{"foo", "bar", "baz"}

	//字符串链接,把slice a通过sep链接起来
	fmt.Println(strings.Join(s, ", "))

	//在字符串s中查找sep所在的位置,返回位置值,找不到返回-1
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dmr"))

	//重复s字符串count次,最后返回重复的字符串
	fmt.Println("ba" + strings.Repeat("na", 2))

	//在s字符串中,把old字符串替换为new字符串,n表示替换的次数,小于0表示全部替换
	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))

	//把s字符串按照sep分割,返回slice
	fmt.Printf("%q\n", strings.Split("a,b,c", ","))
	fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
	fmt.Printf("%q\n", strings.Split(" xyz ", ""))
	fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))

	//在s字符串中去除cutset指定的字符串
	fmt.Printf("[%q]\n", strings.Trim(" !!! Achtung !!! ", "! "))

	//去除s字符串的空格符,并且按照空格分割返回slice
	fmt.Printf("Fields are: %q\n", strings.Fields("  foo bar  baz   "))

	//Append 系列函数将整数等转换为字符串后,添加到现有的字节数组中。
	str := make([]byte, 0, 100)
	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "abcdefg")
	str = strconv.AppendQuoteRune(str, '单')
	fmt.Println(string(str))
	//Format 系列函数把其他类型的转换为字符串
	a := strconv.FormatBool(false)
	b := strconv.FormatFloat(123.23, 'g', 12, 64)
	c := strconv.FormatInt(1234, 10)
	d := strconv.FormatUint(12345, 10)
	e := strconv.Itoa(1023)
	fmt.Println(a, b, c, d, e)

}
Beispiel #10
0
func main() {
	str := make([]byte, 0, 100)
	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "adcdef")
	str = strconv.AppendQuoteRune(str, '中')
	fmt.Println(string(str))

	fl := strconv.FormatFloat(123.23, 'g', 12, 64)
	fmt.Println(fl)

	ui, err := strconv.ParseUint("12345", 10, 64)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(ui + 10)
}
Beispiel #11
0
func getTrids(tag string) ([]string, error) {
	quoted := strconv.AppendQuote(nil, tag)

	trids := []string{}
	err := db.View(func(tx *bolt.Tx) error {
		b := tx.Bucket(tag2trid)
		c := b.Cursor()
		for k, _ := c.Seek(quoted); k != nil; k, _ = c.Next() {
			if !bytes.HasPrefix(k, quoted) {
				break
			}
			trids = append(trids, string(k[len(quoted):]))
		}
		return nil
	})
	return trids, err
}
Beispiel #12
0
func main() {
	for _, truth := range []string{"1", "t", "TRUE", "false", "F", "0", "5"} {
		if b, err := strconv.ParseBool(truth); err != nil {
			fmt.Printf("\n%v", err)
		} else {
			fmt.Print(b, " ")
		}
	}
	fmt.Println()

	x, err := strconv.ParseFloat("-99.7", 64)
	fmt.Printf("%8T %6v %v\n", x, x, err)
	y, err := strconv.ParseInt("71309", 10, 16)
	fmt.Printf("%8T %6v %v\n", y, y, err)
	z, err := strconv.Atoi("71309")
	fmt.Printf("%8T %6v %v\n", z, z, err)
	fmt.Println()

	s := strconv.FormatBool(z > 100)
	fmt.Println(s)
	i, err := strconv.ParseInt("0xDEED", 0, 32)
	fmt.Println(i, err)
	j, err := strconv.ParseInt("0707", 0, 32)
	fmt.Println(j, err)
	k, err := strconv.ParseInt("10111010001", 2, 32)
	fmt.Println(k, err)

	m := 16769023
	fmt.Println(strconv.Itoa(m))
	fmt.Println(strconv.FormatInt(int64(m), 10))
	fmt.Println(strconv.FormatInt(int64(m), 2))
	fmt.Println(strconv.FormatInt(int64(m), 16))
	fmt.Println()

	s = "Alle ønsker å være fri."
	quoted := strconv.QuoteToASCII(s)
	fmt.Println(quoted)
	fmt.Println(strconv.Unquote(quoted))

	var bs []byte
	bs = strconv.AppendQuote(bs, "👍")
	fmt.Printf("|%s|% #x|%d|\n", string(bs), bs, bs)
}
Beispiel #13
0
func (c *C) logMultiLine(s string) {
	b := make([]byte, 0, len(s)*2)
	i := 0
	n := len(s)
	for i < n {
		j := i + 1
		for j < n && s[j-1] != '\n' {
			j++
		}
		b = append(b, "...     "...)
		b = strconv.AppendQuote(b, s[i:j])
		if j < n {
			b = append(b, " +"...)
		}
		b = append(b, '\n')
		i = j
	}
	c.writeLog(b)
}
func processString() {
	str := make([]byte, 0, 100)
	// str := ""
	fmt.Println(str)
	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "abcde")
	str = strconv.AppendQuoteRune(str, '周')

	fmt.Println(str)
	fmt.Println(string(str))

	str1 := strconv.FormatBool(false)
	fmt.Println(str1)

	str1 = strings.Repeat(str1, 2)
	fmt.Println(str1)
	fmt.Println(strings.Contains(str1, "al"))
	fmt.Println(strings.Index(str1, "al"))
	fmt.Println(strings.Trim("!a     james  May       !a", "!a"))
}
Beispiel #15
0
func main() {

	// Append , 转换并添加到现有字符串
	str := make([]byte, 0, 1000)

	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "abcdefg")
	str = strconv.AppendQuoteRune(str, '单')

	fmt.Println(string(str))

	// Format 把其他类型转成字符串
	a := strconv.FormatBool(false)
	b := strconv.FormatFloat(123.23, 'g', 12, 64)
	c := strconv.FormatInt(1234, 10)
	d := strconv.FormatUint(12345, 10)
	e := strconv.Itoa(1023)

	fmt.Println(a, b, c, d, e)

	// Parse 把字符串转为其他类型

	a1, err := strconv.ParseBool("false")
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(a1)
	}

	b1, err := strconv.ParseFloat("123.23", 64)

	c1, err := strconv.ParseInt("1234", 10, 64)

	d1, err := strconv.ParseUint("12345", 10, 64)

	fmt.Println(a1, b1, c1, d1)

}
Beispiel #16
0
func prettyPrint(w *WorldDat, v reflect.Value, buf, indent []byte, outerTag reflect.StructTag) []byte {
	bufPreType := buf
	buf = append(buf, v.Kind().String()...)
	buf = append(buf, ' ')
	if v.Type().String() != v.Kind().String() {
		buf = append(buf, v.Type().String()...)
		buf = append(buf, ' ')
	}

	if p, ok := v.Interface().(prettyPrinter); ok {
		return p.prettyPrint(w, buf, indent, outerTag)
	}

	switch v.Kind() {
	case reflect.Ptr:
		if v.IsNil() {
			buf = append(buf, "(nil)"...)
		} else {
			buf = append(bufPreType, '&')
			buf = prettyPrint(w, v.Elem(), buf, indent, outerTag)
		}

	case reflect.Struct:
		buf = append(buf, '{')
		indent = append(indent, '\t')

		for i, l := 0, v.NumField(); i < l; i++ {
			fieldTag := v.Type().Field(i).Tag
			if tag := fieldTag.Get("df2014_version_min"); tag != "" {
				expected, err := strconv.ParseUint(tag, 0, 32)
				if err != nil {
					panic(err)
				}

				if w.Version < versions.Version(expected) {
					continue
				}
			}
			if tag := fieldTag.Get("df2014_version_max"); tag != "" {
				expected, err := strconv.ParseUint(tag, 0, 32)
				if err != nil {
					panic(err)
				}

				if w.Version > versions.Version(expected) {
					continue
				}
			}
			if tag := fieldTag.Get("df2014_type"); tag != "" {
				expected, err := strconv.ParseInt(tag, 0, 64)
				if err != nil {
					panic(err)
				}

				if v.FieldByName("Type").Int() != expected {
					continue
				}
			}
			buf = append(buf, indent...)
			buf = append(buf, v.Type().Field(i).Name...)
			buf = append(buf, ": "...)
			buf = prettyPrint(w, v.Field(i), buf, indent, fieldTag)
		}

		buf = append(buf, indent[:len(indent)-1]...)
		buf = append(buf, '}')

	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		buf = strconv.AppendInt(buf, v.Int(), 10)
		buf = append(buf, " (0x"...)
		buf = strconv.AppendUint(buf, uint64(v.Int())&(1<<uint(v.Type().Bits())-1), 16)
		buf = append(buf, ')')

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		buf = strconv.AppendUint(buf, v.Uint(), 10)
		buf = append(buf, " (0x"...)
		buf = strconv.AppendUint(buf, v.Uint(), 16)
		buf = append(buf, ')')

	case reflect.String:
		buf = append(buf, "(len = "...)
		buf = strconv.AppendInt(buf, int64(len([]rune(v.String()))), 10)
		buf = append(buf, ") "...)
		buf = strconv.AppendQuote(buf, v.String())

	case reflect.Bool:
		buf = strconv.AppendBool(buf, v.Bool())

	case reflect.Slice, reflect.Array:
		if v.Kind() == reflect.Slice {
			buf = append(buf, "(len = "...)
			buf = strconv.AppendInt(buf, int64(v.Len()), 10)
			buf = append(buf, ") {"...)
		} else {
			buf = append(buf, '{')
		}
		indent = append(indent, '\t')

		var names []string
		if tag := outerTag.Get("df2014_key_is_string"); tag != "" {
			names = reflect.ValueOf(w.StringTables).FieldByName(tag).Interface().([]string)
		}
		for i, l := 0, v.Len(); i < l; i++ {
			buf = append(buf, indent...)
			buf = strconv.AppendInt(buf, int64(i), 10)
			if i >= 0 && int(i) < len(names) {
				buf = append(buf, " ("...)
				buf = append(buf, names[i]...)
				buf = append(buf, ')')
			}
			buf = append(buf, ": "...)
			buf = prettyPrint(w, v.Index(i), buf, indent, "")
		}

		buf = append(buf, indent[:len(indent)-1]...)
		buf = append(buf, '}')

	case reflect.Map:
		buf = append(buf, "(len = "...)
		buf = strconv.AppendInt(buf, int64(v.Len()), 10)
		buf = append(buf, ") {"...)
		indent = append(indent, '\t')

		var elements mapElements
		keys := v.MapKeys()
		for _, key := range keys {
			elements = append(elements, mapElement{key: key, value: v.MapIndex(key)})
		}

		sort.Sort(elements)

		for _, e := range elements {
			buf = append(buf, indent...)
			buf = prettyPrint(w, e.key, buf, indent, "")
			buf = append(buf, ": "...)
			buf = prettyPrint(w, e.value, buf, indent, "")
		}

		buf = append(buf, indent[:len(indent)-1]...)
		buf = append(buf, '}')

	default:
		panic("unhandled type: " + v.Kind().String() + " " + v.Type().String())
	}

	return buf
}
Beispiel #17
0
func (par *stringParser) WriteValue(out io.Writer, valueOf reflect.Value) error {
	_, err := out.Write(strconv.AppendQuote(nil, valueOf.String()))
	return err
}
Beispiel #18
0
func main() {

	// Go offers several printing "verbs" designed to
	// format general Go values. For example, this prints
	// an instance of our `point` struct.
	p := point{1, 2}
	fmt.Printf("%v\n", p)

	// If the value is a struct, the `%+v` variant will
	// include the struct's field names.
	fmt.Printf("%+v\n", p)

	// The `%#v` variant prints a Go syntax representation
	// of the value, i.e. the source code snippet that
	// would produce that value.
	fmt.Printf("%#v\n", p)

	// To print the type of a value, use `%T`.
	fmt.Printf("%T\n", p)

	// Formatting booleans is straight-forward.
	fmt.Printf("%t\n", true)

	// There are many options for formatting integers.
	// Use `%d` for standard, base-10 formatting.
	fmt.Printf("%d\n", 123)

	// This prints a binary representation.
	fmt.Printf("%b\n", 14)

	// This prints the character corresponding to the
	// given integer.
	fmt.Printf("%c\n", 33)

	// `%x` provides hex encoding.
	fmt.Printf("%x\n", 456)

	// There are also several formatting options for
	// floats. For basic decimal formatting use `%f`.
	fmt.Printf("%f\n", 78.9)

	// `%e` and `%E` format the float in (slightly
	// different versions of) scientific notation.
	fmt.Printf("%e\n", 123400000.0)
	fmt.Printf("%E\n", 123400000.0)

	// For basic string printing use `%s`.
	fmt.Printf("%s\n", "\"string\"")

	// To double-quote strings as in Go source, use `%q`.
	fmt.Printf("%q\n", "\"string\"")

	// As with integers seen earlier, `%x` renders
	// the string in base-16, with two output characters
	// per byte of input.
	fmt.Printf("%x\n", "hex this")

	// To print a representation of a pointer, use `%p`.
	fmt.Printf("%p\n", &p)

	// When formatting numbers you will often want to
	// control the width and precision of the resulting
	// figure. To specify the width of an integer, use a
	// number after the `%` in the verb. By default the
	// result will be right-justified and padded with
	// spaces.
	fmt.Printf("|%6d|%6d|\n", 12, 345)

	// You can also specify the width of printed floats,
	// though usually you'll also want to restrict the
	// decimal precision at the same time with the
	// width.precision syntax.
	fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

	// To left-justify, use the `-` flag.
	fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

	// You may also want to control width when formatting
	// strings, especially to ensure that they align in
	// table-like output. For basic right-justified width.
	fmt.Printf("|%6s|%6s|\n", "foo", "b")

	// To left-justify use the `-` flag as with numbers.
	fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

	// So far we've seen `Printf`, which prints the
	// formatted string to `os.Stdout`. `Sprintf` formats
	// and returns a string without printing it anywhere.
	s := fmt.Sprintf("a %s", "string")
	fmt.Println(s)

	// You can format+print to `io.Writers` other than
	// `os.Stdout` using `Fprintf`.
	fmt.Fprintf(os.Stderr, "an %s\n", "error")

	bs := []byte{}
	str := "this is a test!"
	c := len(str)
	bs = strconv.AppendInt(bs, int64(c), 10)
	bs = strconv.AppendQuote(bs, str)
	bs = strconv.AppendInt(bs, 123, 10)
	bs = strconv.AppendBool(bs, true)
	bs = strconv.AppendFloat(bs, 1.23, 'f', -1, 64)
	fmt.Println("string:", string(bs), " len:", len(bs))

	fmt.Println("bool: ", strconv.FormatBool(true))
	fmt.Println("2 int: ", strconv.FormatInt(123, 10))
	fmt.Println("36 int: ", strconv.FormatInt(123, 2))
	fmt.Println("2 uint: ", strconv.FormatUint(123, 10))
	fmt.Println("36 uint: ", strconv.FormatUint(123, 2))
	fmt.Println("float b: ", strconv.FormatFloat(1.230, 'b', -1, 64))
	fmt.Println("float E: ", strconv.FormatFloat(1.230, 'E', -1, 64))
	fmt.Println("float e: ", strconv.FormatFloat(1.230, 'e', -1, 64))
	fmt.Println("float f: ", strconv.FormatFloat(1.2301231, 'f', 6, 64))
	fmt.Println("float G: ", strconv.FormatFloat(1.23012321, 'G', 6, 64))
	fmt.Println("float g: ", strconv.FormatFloat(1.230123213, 'g', 6, 64))

	reader := strings.NewReader(str)
	b, _ := reader.ReadByte()
	fmt.Println(strconv.Atoi(string(b)))
}
Beispiel #19
0
func (bs Bytes) AppendQuote(s string) Bytes {
	r := strconv.AppendQuote([]byte(bs), s)
	return Bytes(r)
}
Beispiel #20
0
func quoteString(v interface{}) string {
	b := []byte{}
	b = strconv.AppendQuote(b, fmt.Sprintf("%v", v))
	return string(b)
}
Beispiel #21
0
func formatDataKey(buf []byte, k []byte) ([]byte, error) {
	if len(k) < 2 {
		return nil, errInvalidBinLogEvent
	}

	buf = append(buf, fmt.Sprintf("DB:%2d ", k[0])...)
	buf = append(buf, fmt.Sprintf("%s ", TypeName[k[1]])...)

	db := new(DB)
	db.index = k[0]

	//to do format at respective place

	switch k[1] {
	case KVType:
		if key, err := db.decodeKVKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
		}
	case HashType:
		if key, field, err := db.hDecodeHashKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendQuote(buf, String(field))
		}
	case HSizeType:
		if key, err := db.hDecodeSizeKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
		}
	case ListType:
		if key, seq, err := db.lDecodeListKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendInt(buf, int64(seq), 10)
		}
	case LMetaType:
		if key, err := db.lDecodeMetaKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
		}
	case ZSetType:
		if key, m, err := db.zDecodeSetKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendQuote(buf, String(m))
		}
	case ZSizeType:
		if key, err := db.zDecodeSizeKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
		}
	case ZScoreType:
		if key, m, score, err := db.zDecodeScoreKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendQuote(buf, String(m))
			buf = append(buf, ' ')
			buf = strconv.AppendInt(buf, score, 10)
		}
	case BitType:
		if key, seq, err := db.bDecodeBinKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendUint(buf, uint64(seq), 10)
		}
	case BitMetaType:
		if key, err := db.bDecodeMetaKey(k); err != nil {
			return nil, err
		} else {
			buf = strconv.AppendQuote(buf, String(key))
		}
	case ExpTimeType:
		if tp, key, t, err := db.expDecodeTimeKey(k); err != nil {
			return nil, err
		} else {
			buf = append(buf, TypeName[tp]...)
			buf = append(buf, ' ')
			buf = strconv.AppendQuote(buf, String(key))
			buf = append(buf, ' ')
			buf = strconv.AppendInt(buf, t, 10)
		}
	case ExpMetaType:
		if tp, key, err := db.expDecodeMetaKey(k); err != nil {
			return nil, err
		} else {
			buf = append(buf, TypeName[tp]...)
			buf = append(buf, ' ')
			buf = strconv.AppendQuote(buf, String(key))
		}
	default:
		return nil, errInvalidBinLogEvent
	}

	return buf, nil
}
Beispiel #22
0
func encodeString(buf []byte, s string) []byte {
	return strconv.AppendQuote(buf, s)
}
// WriteStringValues always writes quoted strings to the buffer
func (b *recordBuffer) WriteStringValues(s ...string) {
	var t []byte
	t = strconv.AppendQuote(t, strings.Join(s, ` `))
	_, _ = b.Write(t)
	b.writeSpace()
}
Beispiel #24
0
func (b *buffer) appendQuote(s string) {
	b.buf = strconv.AppendQuote(b.buf, s)
}