Lines Matching refs:cmd
29 for _, cmd := range cmds {
30 if cmd.Err() == nil {
31 cmd.SetErr(e)
37 for _, cmd := range cmds {
38 if err := cmd.Err(); err != nil {
46 for _, cmd := range cmds {
47 if err := writeCmd(wr, cmd); err != nil {
54 func writeCmd(wr *proto.Writer, cmd Cmder) error {
55 return wr.WriteArgs(cmd.Args())
58 func cmdString(cmd Cmder, val interface{}) string {
59 ss := make([]string, 0, len(cmd.Args()))
60 for _, arg := range cmd.Args() {
64 if err := cmd.Err(); err != nil {
78 func cmdFirstKeyPos(cmd Cmder, info *CommandInfo) int {
79 switch cmd.Name() {
81 if cmd.stringArg(2) != "0" {
106 func (cmd *baseCmd) Name() string {
107 if len(cmd.args) == 0 {
111 return internal.ToLower(cmd.stringArg(0))
114 func (cmd *baseCmd) Args() []interface{} {
115 return cmd.args
118 func (cmd *baseCmd) stringArg(pos int) string {
119 if pos < 0 || pos >= len(cmd.args) {
122 s, _ := cmd.args[pos].(string)
126 func (cmd *baseCmd) SetErr(e error) {
127 cmd.err = e
130 func (cmd *baseCmd) Err() error {
131 return cmd.err
134 func (cmd *baseCmd) readTimeout() *time.Duration {
135 return cmd._readTimeout
138 func (cmd *baseCmd) setReadTimeout(d time.Duration) {
139 cmd._readTimeout = &d
156 func (cmd *Cmd) String() string {
157 return cmdString(cmd, cmd.val)
160 func (cmd *Cmd) Val() interface{} {
161 return cmd.val
164 func (cmd *Cmd) Result() (interface{}, error) {
165 return cmd.val, cmd.err
168 func (cmd *Cmd) Text() (string, error) {
169 if cmd.err != nil {
170 return "", cmd.err
172 switch val := cmd.val.(type) {
181 func (cmd *Cmd) Int() (int, error) {
182 if cmd.err != nil {
183 return 0, cmd.err
185 switch val := cmd.val.(type) {
196 func (cmd *Cmd) Int64() (int64, error) {
197 if cmd.err != nil {
198 return 0, cmd.err
200 switch val := cmd.val.(type) {
211 func (cmd *Cmd) Uint64() (uint64, error) {
212 if cmd.err != nil {
213 return 0, cmd.err
215 switch val := cmd.val.(type) {
226 func (cmd *Cmd) Float32() (float32, error) {
227 if cmd.err != nil {
228 return 0, cmd.err
230 switch val := cmd.val.(type) {
245 func (cmd *Cmd) Float64() (float64, error) {
246 if cmd.err != nil {
247 return 0, cmd.err
249 switch val := cmd.val.(type) {
260 func (cmd *Cmd) Bool() (bool, error) {
261 if cmd.err != nil {
262 return false, cmd.err
264 switch val := cmd.val.(type) {
275 func (cmd *Cmd) readReply(rd *proto.Reader) error {
276 cmd.val, cmd.err = rd.ReadReply(sliceParser)
277 return cmd.err
317 func (cmd *SliceCmd) Val() []interface{} {
318 return cmd.val
321 func (cmd *SliceCmd) Result() ([]interface{}, error) {
322 return cmd.val, cmd.err
325 func (cmd *SliceCmd) String() string {
326 return cmdString(cmd, cmd.val)
329 func (cmd *SliceCmd) readReply(rd *proto.Reader) error {
331 v, cmd.err = rd.ReadArrayReply(sliceParser)
332 if cmd.err != nil {
333 return cmd.err
335 cmd.val = v.([]interface{})
355 func (cmd *StatusCmd) Val() string {
356 return cmd.val
359 func (cmd *StatusCmd) Result() (string, error) {
360 return cmd.val, cmd.err
363 func (cmd *StatusCmd) String() string {
364 return cmdString(cmd, cmd.val)
367 func (cmd *StatusCmd) readReply(rd *proto.Reader) error {
368 cmd.val, cmd.err = rd.ReadString()
369 return cmd.err
388 func (cmd *IntCmd) Val() int64 {
389 return cmd.val
392 func (cmd *IntCmd) Result() (int64, error) {
393 return cmd.val, cmd.err
396 func (cmd *IntCmd) Uint64() (uint64, error) {
397 return uint64(cmd.val), cmd.err
400 func (cmd *IntCmd) String() string {
401 return cmdString(cmd, cmd.val)
404 func (cmd *IntCmd) readReply(rd *proto.Reader) error {
405 cmd.val, cmd.err = rd.ReadIntReply()
406 return cmd.err
425 func (cmd *IntSliceCmd) Val() []int64 {
426 return cmd.val
429 func (cmd *IntSliceCmd) Result() ([]int64, error) {
430 return cmd.val, cmd.err
433 func (cmd *IntSliceCmd) String() string {
434 return cmdString(cmd, cmd.val)
437 func (cmd *IntSliceCmd) readReply(rd *proto.Reader) error {
438 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
439 cmd.val = make([]int64, n)
440 for i := 0; i < len(cmd.val); i++ {
445 cmd.val[i] = num
449 return cmd.err
470 func (cmd *DurationCmd) Val() time.Duration {
471 return cmd.val
474 func (cmd *DurationCmd) Result() (time.Duration, error) {
475 return cmd.val, cmd.err
478 func (cmd *DurationCmd) String() string {
479 return cmdString(cmd, cmd.val)
482 func (cmd *DurationCmd) readReply(rd *proto.Reader) error {
484 n, cmd.err = rd.ReadIntReply()
485 if cmd.err != nil {
486 return cmd.err
492 cmd.val = time.Duration(n)
494 cmd.val = time.Duration(n) * cmd.precision
515 func (cmd *TimeCmd) Val() time.Time {
516 return cmd.val
519 func (cmd *TimeCmd) Result() (time.Time, error) {
520 return cmd.val, cmd.err
523 func (cmd *TimeCmd) String() string {
524 return cmdString(cmd, cmd.val)
527 func (cmd *TimeCmd) readReply(rd *proto.Reader) error {
528 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
543 cmd.val = time.Unix(sec, microsec*1000)
546 return cmd.err
565 func (cmd *BoolCmd) Val() bool {
566 return cmd.val
569 func (cmd *BoolCmd) Result() (bool, error) {
570 return cmd.val, cmd.err
573 func (cmd *BoolCmd) String() string {
574 return cmdString(cmd, cmd.val)
577 func (cmd *BoolCmd) readReply(rd *proto.Reader) error {
579 v, cmd.err = rd.ReadReply(nil)
582 if cmd.err == Nil {
583 cmd.val = false
584 cmd.err = nil
587 if cmd.err != nil {
588 return cmd.err
592 cmd.val = v == 1
595 cmd.val = v == "OK"
598 cmd.err = fmt.Errorf("got %T, wanted int64 or string", v)
599 return cmd.err
619 func (cmd *StringCmd) Val() string {
620 return cmd.val
623 func (cmd *StringCmd) Result() (string, error) {
624 return cmd.Val(), cmd.err
627 func (cmd *StringCmd) Bytes() ([]byte, error) {
628 return util.StringToBytes(cmd.val), cmd.err
631 func (cmd *StringCmd) Int() (int, error) {
632 if cmd.err != nil {
633 return 0, cmd.err
635 return strconv.Atoi(cmd.Val())
638 func (cmd *StringCmd) Int64() (int64, error) {
639 if cmd.err != nil {
640 return 0, cmd.err
642 return strconv.ParseInt(cmd.Val(), 10, 64)
645 func (cmd *StringCmd) Uint64() (uint64, error) {
646 if cmd.err != nil {
647 return 0, cmd.err
649 return strconv.ParseUint(cmd.Val(), 10, 64)
652 func (cmd *StringCmd) Float32() (float32, error) {
653 if cmd.err != nil {
654 return 0, cmd.err
656 f, err := strconv.ParseFloat(cmd.Val(), 32)
663 func (cmd *StringCmd) Float64() (float64, error) {
664 if cmd.err != nil {
665 return 0, cmd.err
667 return strconv.ParseFloat(cmd.Val(), 64)
670 func (cmd *StringCmd) Time() (time.Time, error) {
671 if cmd.err != nil {
672 return time.Time{}, cmd.err
674 return time.Parse(time.RFC3339, cmd.Val())
677 func (cmd *StringCmd) Scan(val interface{}) error {
678 if cmd.err != nil {
679 return cmd.err
681 return proto.Scan([]byte(cmd.val), val)
684 func (cmd *StringCmd) String() string {
685 return cmdString(cmd, cmd.val)
688 func (cmd *StringCmd) readReply(rd *proto.Reader) error {
689 cmd.val, cmd.err = rd.ReadString()
690 return cmd.err
709 func (cmd *FloatCmd) Val() float64 {
710 return cmd.val
713 func (cmd *FloatCmd) Result() (float64, error) {
714 return cmd.Val(), cmd.Err()
717 func (cmd *FloatCmd) String() string {
718 return cmdString(cmd, cmd.val)
721 func (cmd *FloatCmd) readReply(rd *proto.Reader) error {
722 cmd.val, cmd.err = rd.ReadFloatReply()
723 return cmd.err
742 func (cmd *StringSliceCmd) Val() []string {
743 return cmd.val
746 func (cmd *StringSliceCmd) Result() ([]string, error) {
747 return cmd.Val(), cmd.Err()
750 func (cmd *StringSliceCmd) String() string {
751 return cmdString(cmd, cmd.val)
754 func (cmd *StringSliceCmd) ScanSlice(container interface{}) error {
755 return proto.ScanSlice(cmd.Val(), container)
758 func (cmd *StringSliceCmd) readReply(rd *proto.Reader) error {
759 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
760 cmd.val = make([]string, n)
761 for i := 0; i < len(cmd.val); i++ {
764 cmd.val[i] = ""
768 cmd.val[i] = s
773 return cmd.err
792 func (cmd *BoolSliceCmd) Val() []bool {
793 return cmd.val
796 func (cmd *BoolSliceCmd) Result() ([]bool, error) {
797 return cmd.val, cmd.err
800 func (cmd *BoolSliceCmd) String() string {
801 return cmdString(cmd, cmd.val)
804 func (cmd *BoolSliceCmd) readReply(rd *proto.Reader) error {
805 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
806 cmd.val = make([]bool, n)
807 for i := 0; i < len(cmd.val); i++ {
812 cmd.val[i] = n == 1
816 return cmd.err
835 func (cmd *StringStringMapCmd) Val() map[string]string {
836 return cmd.val
839 func (cmd *StringStringMapCmd) Result() (map[string]string, error) {
840 return cmd.val, cmd.err
843 func (cmd *StringStringMapCmd) String() string {
844 return cmdString(cmd, cmd.val)
847 func (cmd *StringStringMapCmd) readReply(rd *proto.Reader) error {
848 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
849 cmd.val = make(map[string]string, n/2)
861 cmd.val[key] = value
865 return cmd.err
884 func (cmd *StringIntMapCmd) Val() map[string]int64 {
885 return cmd.val
888 func (cmd *StringIntMapCmd) Result() (map[string]int64, error) {
889 return cmd.val, cmd.err
892 func (cmd *StringIntMapCmd) String() string {
893 return cmdString(cmd, cmd.val)
896 func (cmd *StringIntMapCmd) readReply(rd *proto.Reader) error {
897 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
898 cmd.val = make(map[string]int64, n/2)
910 cmd.val[key] = n
914 return cmd.err
933 func (cmd *StringStructMapCmd) Val() map[string]struct{} {
934 return cmd.val
937 func (cmd *StringStructMapCmd) Result() (map[string]struct{}, error) {
938 return cmd.val, cmd.err
941 func (cmd *StringStructMapCmd) String() string {
942 return cmdString(cmd, cmd.val)
945 func (cmd *StringStructMapCmd) readReply(rd *proto.Reader) error {
946 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
947 cmd.val = make(map[string]struct{}, n)
953 cmd.val[key] = struct{}{}
957 return cmd.err
981 func (cmd *XMessageSliceCmd) Val() []XMessage {
982 return cmd.val
985 func (cmd *XMessageSliceCmd) Result() ([]XMessage, error) {
986 return cmd.val, cmd.err
989 func (cmd *XMessageSliceCmd) String() string {
990 return cmdString(cmd, cmd.val)
993 func (cmd *XMessageSliceCmd) readReply(rd *proto.Reader) error {
995 v, cmd.err = rd.ReadArrayReply(xMessageSliceParser)
996 if cmd.err != nil {
997 return cmd.err
999 cmd.val = v.([]XMessage)
1078 func (cmd *XStreamSliceCmd) Val() []XStream {
1079 return cmd.val
1082 func (cmd *XStreamSliceCmd) Result() ([]XStream, error) {
1083 return cmd.val, cmd.err
1086 func (cmd *XStreamSliceCmd) String() string {
1087 return cmdString(cmd, cmd.val)
1090 func (cmd *XStreamSliceCmd) readReply(rd *proto.Reader) error {
1091 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1092 cmd.val = make([]XStream, n)
1093 for i := 0; i < len(cmd.val); i++ {
1110 cmd.val[i] = XStream{
1122 return cmd.err
1147 func (cmd *XPendingCmd) Val() *XPending {
1148 return cmd.val
1151 func (cmd *XPendingCmd) Result() (*XPending, error) {
1152 return cmd.val, cmd.err
1155 func (cmd *XPendingCmd) String() string {
1156 return cmdString(cmd, cmd.val)
1159 func (cmd *XPendingCmd) readReply(rd *proto.Reader) error {
1160 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1180 cmd.val = &XPending{
1202 if cmd.val.Consumers == nil {
1203 cmd.val.Consumers = make(map[string]int64)
1205 cmd.val.Consumers[consumerName] = consumerPending
1221 return cmd.err
1246 func (cmd *XPendingExtCmd) Val() []XPendingExt {
1247 return cmd.val
1250 func (cmd *XPendingExtCmd) Result() ([]XPendingExt, error) {
1251 return cmd.val, cmd.err
1254 func (cmd *XPendingExtCmd) String() string {
1255 return cmdString(cmd, cmd.val)
1258 func (cmd *XPendingExtCmd) readReply(rd *proto.Reader) error {
1259 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1260 cmd.val = make([]XPendingExt, 0, n)
1287 cmd.val = append(cmd.val, XPendingExt{
1301 return cmd.err
1326 func (cmd *XInfoGroupsCmd) Val() []XInfoGroups {
1327 return cmd.val
1330 func (cmd *XInfoGroupsCmd) Result() ([]XInfoGroups, error) {
1331 return cmd.val, cmd.err
1334 func (cmd *XInfoGroupsCmd) String() string {
1335 return cmdString(cmd, cmd.val)
1338 func (cmd *XInfoGroupsCmd) readReply(rd *proto.Reader) error {
1339 _, cmd.err = rd.ReadArrayReply(
1346 cmd.val = append(cmd.val, v.(XInfoGroups))
1410 func (cmd *ZSliceCmd) Val() []Z {
1411 return cmd.val
1414 func (cmd *ZSliceCmd) Result() ([]Z, error) {
1415 return cmd.val, cmd.err
1418 func (cmd *ZSliceCmd) String() string {
1419 return cmdString(cmd, cmd.val)
1422 func (cmd *ZSliceCmd) readReply(rd *proto.Reader) error {
1423 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1424 cmd.val = make([]Z, n/2)
1425 for i := 0; i < len(cmd.val); i++ {
1436 cmd.val[i] = Z{
1443 return cmd.err
1462 func (cmd *ZWithKeyCmd) Val() *ZWithKey {
1463 return cmd.val
1466 func (cmd *ZWithKeyCmd) Result() (*ZWithKey, error) {
1467 return cmd.Val(), cmd.Err()
1470 func (cmd *ZWithKeyCmd) String() string {
1471 return cmdString(cmd, cmd.val)
1474 func (cmd *ZWithKeyCmd) readReply(rd *proto.Reader) error {
1475 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1480 cmd.val = &ZWithKey{}
1483 cmd.val.Key, err = rd.ReadString()
1488 cmd.val.Member, err = rd.ReadString()
1493 cmd.val.Score, err = rd.ReadFloatReply()
1500 return cmd.err
1511 process func(cmd Cmder) error
1516 func NewScanCmd(process func(cmd Cmder) error, args ...interface{}) *ScanCmd {
1523 func (cmd *ScanCmd) Val() (keys []string, cursor uint64) {
1524 return cmd.page, cmd.cursor
1527 func (cmd *ScanCmd) Result() (keys []string, cursor uint64, err error) {
1528 return cmd.page, cmd.cursor, cmd.err
1531 func (cmd *ScanCmd) String() string {
1532 return cmdString(cmd, cmd.page)
1535 func (cmd *ScanCmd) readReply(rd *proto.Reader) error {
1536 cmd.page, cmd.cursor, cmd.err = rd.ReadScanReply()
1537 return cmd.err
1541 func (cmd *ScanCmd) Iterator() *ScanIterator {
1543 cmd: cmd,
1574 func (cmd *ClusterSlotsCmd) Val() []ClusterSlot {
1575 return cmd.val
1578 func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error) {
1579 return cmd.Val(), cmd.Err()
1582 func (cmd *ClusterSlotsCmd) String() string {
1583 return cmdString(cmd, cmd.val)
1586 func (cmd *ClusterSlotsCmd) readReply(rd *proto.Reader) error {
1587 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1588 cmd.val = make([]ClusterSlot, n)
1589 for i := 0; i < len(cmd.val); i++ {
1641 cmd.val[i] = ClusterSlot{
1649 return cmd.err
1725 func (cmd *GeoLocationCmd) Val() []GeoLocation {
1726 return cmd.locations
1729 func (cmd *GeoLocationCmd) Result() ([]GeoLocation, error) {
1730 return cmd.locations, cmd.err
1733 func (cmd *GeoLocationCmd) String() string {
1734 return cmdString(cmd, cmd.locations)
1737 func (cmd *GeoLocationCmd) readReply(rd *proto.Reader) error {
1739 v, cmd.err = rd.ReadArrayReply(newGeoLocationSliceParser(cmd.q))
1740 if cmd.err != nil {
1741 return cmd.err
1743 cmd.locations = v.([]GeoLocation)
1835 func (cmd *GeoPosCmd) Val() []*GeoPos {
1836 return cmd.val
1839 func (cmd *GeoPosCmd) Result() ([]*GeoPos, error) {
1840 return cmd.Val(), cmd.Err()
1843 func (cmd *GeoPosCmd) String() string {
1844 return cmdString(cmd, cmd.val)
1847 func (cmd *GeoPosCmd) readReply(rd *proto.Reader) error {
1848 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1849 cmd.val = make([]*GeoPos, n)
1850 for i := 0; i < len(cmd.val); i++ {
1863 cmd.val[i] = &GeoPos{
1871 cmd.val[i] = nil
1879 return cmd.err
1908 func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo {
1909 return cmd.val
1912 func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error) {
1913 return cmd.Val(), cmd.Err()
1916 func (cmd *CommandsInfoCmd) String() string {
1917 return cmdString(cmd, cmd.val)
1920 func (cmd *CommandsInfoCmd) readReply(rd *proto.Reader) error {
1921 _, cmd.err = rd.ReadArrayReply(func(rd *proto.Reader, n int64) (interface{}, error) {
1922 cmd.val = make(map[string]*CommandInfo, n)
1929 cmd.val[vv.Name] = vv
1933 return cmd.err
1941 var cmd CommandInfo
1944 cmd.Name, err = rd.ReadString()
1953 cmd.Arity = int8(arity)
1956 cmd.Flags = make([]string, n)
1957 for i := 0; i < len(cmd.Flags); i++ {
1960 cmd.Flags[i] = ""
1964 cmd.Flags[i] = s
1977 cmd.FirstKeyPos = int8(firstKeyPos)
1983 cmd.LastKeyPos = int8(lastKeyPos)
1989 cmd.StepCount = int8(stepCount)
1991 for _, flag := range cmd.Flags {
1993 cmd.ReadOnly = true
1998 return &cmd, nil