func (mc *Connection) store(command, key string, flags uint16, timeout uint64, value []byte, cas uint64) (stored bool) { if len(value) > 1000000 { return false } mc.setDeadline() // <command name> <key> <flags> <exptime> <bytes> [noreply]\r\n mc.writestrings(command, " ", key, " ") mc.write(strconv.AppendUint(nil, uint64(flags), 10)) mc.writestring(" ") mc.write(strconv.AppendUint(nil, timeout, 10)) mc.writestring(" ") mc.write(strconv.AppendInt(nil, int64(len(value)), 10)) if cas != 0 { mc.writestring(" ") mc.write(strconv.AppendUint(nil, cas, 10)) } mc.writestring("\r\n") // <data block>\r\n mc.write(value) mc.writestring("\r\n") reply := mc.readline() if strings.Contains(reply, "ERROR") { panic(NewError("Server error")) } return strings.HasPrefix(reply, "STORED") }
func formatTextValue(value interface{}) ([]byte, error) { switch v := value.(type) { case int8: return strconv.AppendInt(nil, int64(v), 10), nil case int16: return strconv.AppendInt(nil, int64(v), 10), nil case int32: return strconv.AppendInt(nil, int64(v), 10), nil case int64: return strconv.AppendInt(nil, int64(v), 10), nil case int: return strconv.AppendInt(nil, int64(v), 10), nil case uint8: return strconv.AppendUint(nil, uint64(v), 10), nil case uint16: return strconv.AppendUint(nil, uint64(v), 10), nil case uint32: return strconv.AppendUint(nil, uint64(v), 10), nil case uint64: return strconv.AppendUint(nil, uint64(v), 10), nil case uint: return strconv.AppendUint(nil, uint64(v), 10), nil case float32: return strconv.AppendFloat(nil, float64(v), 'f', -1, 64), nil case float64: return strconv.AppendFloat(nil, float64(v), 'f', -1, 64), nil case []byte: return v, nil case string: return hack.Slice(v), nil default: return nil, errors.Errorf("invalid type %T", value) } }
func write_cursor(x, y int) { outbuf.WriteString("\033[") outbuf.Write(strconv.AppendUint(intbuf, uint64(y+1), 10)) outbuf.WriteString(";") outbuf.Write(strconv.AppendUint(intbuf, uint64(x+1), 10)) outbuf.WriteString("H") }
// Version to string func (v Version) String() string { b := make([]byte, 0, 5) b = strconv.AppendUint(b, v.Major, 10) b = append(b, '.') b = strconv.AppendUint(b, v.Minor, 10) b = append(b, '.') b = strconv.AppendUint(b, v.Patch, 10) if len(v.Pre) > 0 { b = append(b, '-') b = append(b, v.Pre[0].String()...) for _, pre := range v.Pre[1:] { b = append(b, '.') b = append(b, pre.String()...) } } if len(v.Build) > 0 { b = append(b, '+') b = append(b, v.Build[0]...) for _, build := range v.Build[1:] { b = append(b, '.') b = append(b, build...) } } return string(b) }
func write_sgr(fg, bg Attribute) { outbuf.WriteString("\033[3") outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) outbuf.WriteString(";4") outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) outbuf.WriteString("m") }
func (s *testFlusherSink) appendNumber(v interface{}) { switch n := v.(type) { case int: s.buf = strconv.AppendInt(s.buf, int64(n), 10) case uint: s.buf = strconv.AppendUint(s.buf, uint64(n), 10) case int64: s.buf = strconv.AppendInt(s.buf, n, 10) case uint64: s.buf = strconv.AppendUint(s.buf, n, 10) case int32: s.buf = strconv.AppendInt(s.buf, int64(n), 10) case uint32: s.buf = strconv.AppendUint(s.buf, uint64(n), 10) case int16: s.buf = strconv.AppendInt(s.buf, int64(n), 10) case uint16: s.buf = strconv.AppendUint(s.buf, uint64(n), 10) case int8: s.buf = strconv.AppendInt(s.buf, int64(n), 10) case uint8: s.buf = strconv.AppendUint(s.buf, uint64(n), 10) case float64: s.buf = strconv.AppendFloat(s.buf, n, 'f', -1, 64) case float32: s.buf = strconv.AppendFloat(s.buf, float64(n), 'f', -1, 32) } }
// Bytes formats the message in a RFC5424 format. func (msg *Message) Bytes() []byte { var b []byte // Format priority: <pri>, e.g. <0>, <191> b = append(b, priorityStart) b = strconv.AppendUint(b, uint64(msg.Priority), 10) b = append(b, priorityEnd) // Add optional version and a space, e.g. 1, 10 if msg.Version != 0 { b = strconv.AppendUint(b, uint64(msg.Version), 10) } b = append(b, spaceByte) // Add values, with a nil value for a zero value. b = addTimestamp(b, msg.Timestamp) b = addValue(b, msg.Hostname) b = addValue(b, msg.Appname) b = addValue(b, msg.ProcessID) b = addValue(b, msg.MessageID) b = addData(b, msg.Data) if msg.Message != "" { b = append(b, spaceByte) b = append(b, msg.Message...) } return b }
func (c *conn) appendNumber(v interface{}) { switch n := v.(type) { case int: c.buf = strconv.AppendInt(c.buf, int64(n), 10) case uint: c.buf = strconv.AppendUint(c.buf, uint64(n), 10) case int64: c.buf = strconv.AppendInt(c.buf, n, 10) case uint64: c.buf = strconv.AppendUint(c.buf, n, 10) case int32: c.buf = strconv.AppendInt(c.buf, int64(n), 10) case uint32: c.buf = strconv.AppendUint(c.buf, uint64(n), 10) case int16: c.buf = strconv.AppendInt(c.buf, int64(n), 10) case uint16: c.buf = strconv.AppendUint(c.buf, uint64(n), 10) case int8: c.buf = strconv.AppendInt(c.buf, int64(n), 10) case uint8: c.buf = strconv.AppendUint(c.buf, uint64(n), 10) case float64: c.buf = strconv.AppendFloat(c.buf, n, 'f', -1, 64) case float32: c.buf = strconv.AppendFloat(c.buf, float64(n), 'f', -1, 32) } }
func BuildValue(goval interface{}) (v Value, err error) { switch bindVal := goval.(type) { case nil: // no op case int: v = Value{Numeric(strconv.AppendInt(nil, int64(bindVal), 10))} case int32: v = Value{Numeric(strconv.AppendInt(nil, int64(bindVal), 10))} case int64: v = Value{Numeric(strconv.AppendInt(nil, int64(bindVal), 10))} case uint: v = Value{Numeric(strconv.AppendUint(nil, uint64(bindVal), 10))} case uint32: v = Value{Numeric(strconv.AppendUint(nil, uint64(bindVal), 10))} case uint64: v = Value{Numeric(strconv.AppendUint(nil, uint64(bindVal), 10))} case float64: v = Value{Fractional(strconv.AppendFloat(nil, bindVal, 'f', -1, 64))} case string: v = Value{String([]byte(bindVal))} case []byte: v = Value{String(bindVal)} case time.Time: v = Value{String([]byte(bindVal.Format("'2006-01-02 15:04:05'")))} case Numeric, Fractional, String: v = Value{bindVal.(InnerValue)} case Value: v = bindVal default: return Value{}, fmt.Errorf("Unsupported bind variable type %T: %v", goval, goval) } return v, nil }
func (c *conn) writeStoreCommand(cmd, key string, value []byte, flags uint32, timeout int32, cas uint64) (err error) { if len(value) > 1000000 { return protocolError("max value size, greate than 1mb") } // <command name> <key> <flags> <exptime> <bytes> [noreply]\r\n c.bw.WriteString(cmd) c.bw.WriteByte(space) c.bw.WriteString(key) c.bw.WriteByte(space) c.bw.Write(strconv.AppendUint(c.numScratch[:0], uint64(flags), 10)) c.bw.WriteByte(space) c.bw.Write(strconv.AppendInt(c.numScratch[:0], int64(timeout), 10)) c.bw.WriteByte(space) c.bw.Write(strconv.AppendInt(c.numScratch[:0], int64(len(value)), 10)) if cas != 0 { c.bw.WriteByte(space) c.bw.Write(strconv.AppendUint(c.numScratch[:0], cas, 10)) } c.bw.Write(crlf) // <data block>\r\n c.bw.Write(value) _, err = c.bw.Write(crlf) return }
func encodeDefault(object interface{}) (buffer []byte, err error) { switch object.(type) { case bool: buffer = strconv.AppendBool(buffer, object.(bool)) case int: buffer = strconv.AppendInt(buffer, int64(object.(int)), _NUMERIC_BASE) case int8: buffer = strconv.AppendInt(buffer, int64(object.(int8)), _NUMERIC_BASE) case int16: buffer = strconv.AppendInt(buffer, int64(object.(int16)), _NUMERIC_BASE) case int32: buffer = strconv.AppendInt(buffer, int64(object.(int32)), _NUMERIC_BASE) case int64: buffer = strconv.AppendInt(buffer, object.(int64), _NUMERIC_BASE) case uint: buffer = strconv.AppendUint(buffer, uint64(object.(uint)), _NUMERIC_BASE) case uint8: buffer = strconv.AppendUint(buffer, uint64(object.(uint8)), _NUMERIC_BASE) case uint16: buffer = strconv.AppendUint(buffer, uint64(object.(uint16)), _NUMERIC_BASE) case uint32: buffer = strconv.AppendUint(buffer, uint64(object.(uint32)), _NUMERIC_BASE) case uint64: buffer = strconv.AppendUint(buffer, object.(uint64), _NUMERIC_BASE) case string: buffer = []byte(object.(string)) case []byte: buffer = object.([]byte) default: err = errors.New("Invalid object for default encode") } return }
func (p Percent) String() string { var buf [12]byte b := strconv.AppendUint(buf[:0], uint64(p)/1000, 10) n := len(b) b = strconv.AppendUint(b, 1000+uint64(p)%1000, 10) b[n] = '.' return string(append(b, '%')) }
func (t TermVT100) Pos(b []byte, x, y int) []byte { b = b[:0] b = append(b, 27, '[') b = strconv.AppendUint(b, uint64(y), 10) b = append(b, ';') b = strconv.AppendUint(b, uint64(x), 10) b = append(b, 'f') return b }
func main() { b10 := []byte("uint (base 10):") b10 = strconv.AppendUint(b10, 42, 10) fmt.Println(string(b10)) b16 := []byte("uint (base 16):") b16 = strconv.AppendUint(b16, 42, 16) fmt.Println(string(b16)) }
func (e *jsonEncDriver) EncodeUint(v uint64) { if x := e.h.IntegerAsString; x == 'A' || x == 'L' && v > 1<<53 { e.w.writen1('"') e.w.writeb(strconv.AppendUint(e.b[:0], v, 10)) e.w.writen1('"') return } e.w.writeb(strconv.AppendUint(e.b[:0], v, 10)) }
func (v *Version) String() string { b := make([]byte, 0, 5) b = strconv.AppendUint(b, v.Major, 10) b = append(b, '.') b = strconv.AppendUint(b, v.Minor, 10) b = append(b, '.') b = strconv.AppendUint(b, v.Patch, 10) return string(b) }
func appendIface(b []byte, vi interface{}, quote bool) []byte { switch v := vi.(type) { case nil: return appendNull(b, quote) case bool: return appendBool(b, v) case int8: return strconv.AppendInt(b, int64(v), 10) case int16: return strconv.AppendInt(b, int64(v), 10) case int32: return strconv.AppendInt(b, int64(v), 10) case int64: return strconv.AppendInt(b, int64(v), 10) case int: return strconv.AppendInt(b, int64(v), 10) case uint8: return strconv.AppendUint(b, uint64(v), 10) case uint16: return strconv.AppendUint(b, uint64(v), 10) case uint32: return strconv.AppendUint(b, uint64(v), 10) case uint64: return strconv.AppendUint(b, v, 10) case uint: return strconv.AppendUint(b, uint64(v), 10) case float32: return appendFloat(b, float64(v)) case float64: return appendFloat(b, v) case string: return appendString(b, v, quote) case time.Time: return appendTime(b, v, quote) case []byte: return appendBytes(b, v, quote) case []string: return appendStringSlice(b, v, quote) case []int: return appendIntSlice(b, v, quote) case []int64: return appendInt64Slice(b, v, quote) case []float64: return appendFloat64Slice(b, v, quote) case map[string]string: return appendStringStringMap(b, v, quote) case QueryAppender: return v.AppendQuery(b) case driver.Valuer: return appendDriverValuer(b, v, quote) default: return appendValue(b, reflect.ValueOf(vi), quote) } }
// AppendRecord appends the (key,value) record to data and returns the // appended slice. func AppendRecord(data, key, value []byte) []byte { data = append(data, '+') data = strconv.AppendUint(data, uint64(len(key)), 10) data = append(data, ',') data = strconv.AppendUint(data, uint64(len(value)), 10) data = append(data, ':') data = append(data, key...) data = append(data, []byte("->")...) data = append(data, value...) return append(data, '\n') }
func write_sgr_fg(a Attribute) { switch output_mode { case Output256, Output216, OutputGrayscale: outbuf.WriteString("\033[38;5;") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") default: outbuf.WriteString("\033[3") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") } }
func encodeReq(buf []byte, args []string) []byte { buf = append(buf, '*') buf = strconv.AppendUint(buf, uint64(len(args)), 10) buf = append(buf, '\r', '\n') for _, arg := range args { buf = append(buf, '$') buf = strconv.AppendUint(buf, uint64(len(arg)), 10) buf = append(buf, '\r', '\n') buf = append(buf, []byte(arg)...) buf = append(buf, '\r', '\n') } return buf }
func (v vector) String() string { buf := []byte{'{'} for i, x := range v.list { if i > 0 { buf = append(buf, ' ') } buf = strconv.AppendUint(buf, uint64(x.id), 10) buf = append(buf, ':') buf = strconv.AppendUint(buf, uint64(x.t), 10) } buf = append(buf, '}') return string(buf) }
// String returns sequence value s as a seq-number or seq-range string. func (s seq) String() string { if s.start == s.stop { if s.start == 0 { return "*" } return strconv.FormatUint(uint64(s.start), 10) } b := strconv.AppendUint(make([]byte, 0, 24), uint64(s.start), 10) if s.stop == 0 { return string(append(b, ':', '*')) } return string(strconv.AppendUint(append(b, ':'), uint64(s.stop), 10)) }
func ExampleAppendUint() { b10 := []byte("uint (base 10):") b10 = strconv.AppendUint(b10, 42, 10) fmt.Println(string(b10)) b16 := []byte("uint (base 16):") b16 = strconv.AppendUint(b16, 42, 16) fmt.Println(string(b16)) // Output: // uint (base 10):42 // uint (base 16):2a }
func (s SID) String() string { if len(s) < 8 || s[0] != sidRevision || len(s) != (int(s[1])*4)+8 { return "" } ret := []byte("S-1-") ret = strconv.AppendUint(ret, binary.BigEndian.Uint64(s[:8])&0xFFFFFFFFFFFF, 10) for i := 0; i < int(s[1]); i++ { ret = append(ret, "-"...) ret = strconv.AppendUint(ret, uint64(binary.LittleEndian.Uint32(s[8+i*4:])), 10) } return string(ret) }
func write_sgr(fg, bg uint) { outbuf.WriteString("\033[3") if fg > 7 { // xterm-256 color outbuf.WriteString("8;5;") } outbuf.Write(strconv.AppendUint(intbuf, uint64(fg), 10)) outbuf.WriteString(";4") if bg > 7 { // xterm-256 color outbuf.WriteString("8;5;") } outbuf.Write(strconv.AppendUint(intbuf, uint64(bg), 10)) outbuf.WriteString("m") }
func Append(b []byte, v interface{}, quote bool) []byte { switch v := v.(type) { case nil: return AppendNull(b, quote) case bool: return appendBool(b, v) case int8: return strconv.AppendInt(b, int64(v), 10) case int16: return strconv.AppendInt(b, int64(v), 10) case int32: return strconv.AppendInt(b, int64(v), 10) case int64: return strconv.AppendInt(b, int64(v), 10) case int: return strconv.AppendInt(b, int64(v), 10) case uint8: return strconv.AppendUint(b, uint64(v), 10) case uint16: return strconv.AppendUint(b, uint64(v), 10) case uint32: return strconv.AppendUint(b, uint64(v), 10) case uint64: return strconv.AppendUint(b, v, 10) case uint: return strconv.AppendUint(b, uint64(v), 10) case float32: return appendFloat(b, float64(v)) case float64: return appendFloat(b, v) case string: return AppendString(b, v, quote) case time.Time: return AppendTime(b, v, quote) case []byte: return appendBytes(b, v, quote) case ValueAppender: b, err := v.AppendValue(b, quote) if err != nil { panic(err) } return b case driver.Valuer: return appendDriverValuer(b, v, quote) default: return appendValue(b, reflect.ValueOf(v), quote) } }
func roleCommand(c *client) error { if len(c.args) != 0 { return ErrCmdParams } c.app.m.Lock() slaveof := c.app.cfg.SlaveOf c.app.m.Unlock() isMaster := len(slaveof) == 0 ay := make([]interface{}, 0, 5) var lastId int64 = 0 stat, _ := c.app.ldb.ReplicationStat() if stat != nil { lastId = int64(stat.LastID) } if isMaster { ay = append(ay, []byte("master")) ay = append(ay, lastId) items := make([]interface{}, 0, 3) c.app.slock.Lock() for addr, slave := range c.app.slaves { host, port, _ := splitHostPort(addr) items = append(items, []interface{}{[]byte(host), strconv.AppendUint(nil, uint64(port), 10), strconv.AppendUint(nil, slave.lastLogID.Get(), 10)}) } c.app.slock.Unlock() ay = append(ay, items) } else { host, port, _ := splitHostPort(slaveof) ay = append(ay, []byte("slave")) ay = append(ay, []byte(host)) ay = append(ay, int64(port)) ay = append(ay, []byte(replStatetring(c.app.m.state.Get()))) ay = append(ay, lastId) } c.resp.writeArray(ay) return nil }
// ValueFromBytes builds a Value using typ and val. It ensures that val // matches the requested type. If type is an integral it's converted to // a cannonical form. Otherwise, the original representation is preserved. func ValueFromBytes(typ querypb.Type, val []byte) (v Value, err error) { switch { case IsSigned(typ): signed, err := strconv.ParseInt(string(val), 0, 64) if err != nil { return NULL, err } v = MakeTrusted(typ, strconv.AppendInt(nil, signed, 10)) case IsUnsigned(typ): unsigned, err := strconv.ParseUint(string(val), 0, 64) if err != nil { return NULL, err } v = MakeTrusted(typ, strconv.AppendUint(nil, unsigned, 10)) case typ == Tuple: return NULL, errors.New("tuple not allowed for ValueFromBytes") case IsFloat(typ) || typ == Decimal: _, err := strconv.ParseFloat(string(val), 64) if err != nil { return NULL, err } // After verification, we preserve the original representation. fallthrough default: v = MakeTrusted(typ, val) } return v, nil }
func (w *WriteBuffer) AppendString(s string) { w.b = append(w.b, StringReply) w.b = strconv.AppendUint(w.b, uint64(len(s)), 10) w.b = append(w.b, '\r', '\n') w.b = append(w.b, s...) w.b = append(w.b, '\r', '\n') }
func (w *WriteBuffer) AppendBytes(p []byte) { w.b = append(w.b, StringReply) w.b = strconv.AppendUint(w.b, uint64(len(p)), 10) w.b = append(w.b, '\r', '\n') w.b = append(w.b, p...) w.b = append(w.b, '\r', '\n') }