[WIP] rueidiscompat — add implementations of 41 more functions

message.go

@@ -201,6 +201,22 @@ func (r RedisResult) AsIntSlice() ([]int64, error) {
 	return r.val.AsIntSlice()
 }
 
+// AsXMessage delegates to RedisMessage.AsXMessage
+func (r RedisResult) AsXMessage() (XMessage, error) {
+	if err := r.Error(); err != nil {
+		return XMessage{}, err
+	}
+	return r.val.AsXMessage()
+}
+
+// AsXMessageSlice delegates to RedisMessage.AsXMessageSlice
+func (r RedisResult) AsXMessageSlice() ([]XMessage, error) {
+	if err := r.Error(); err != nil {
+		return nil, err
+	}
+	return r.val.AsXMessageSlice()
+}
+
 // AsMap delegates to RedisMessage.AsMap
 func (r RedisResult) AsMap() (map[string]RedisMessage, error) {
 	if err := r.Error(); err != nil {
@@ -402,6 +418,52 @@ func (m *RedisMessage) AsIntSlice() ([]int64, error) {
 	return s, nil
 }
 
+type XMessage struct {
+	ID        string
+	KeyValues map[string]string
+}
+
+// AsXMessage check if message is a redis array/set response of length 2, and convert to XMessage
+func (m *RedisMessage) AsXMessage() (XMessage, error) {
+	values, err := m.ToArray()
+	if err != nil {
+		return XMessage{}, err
+	}
+	if len(values) != 2 {
+		return XMessage{}, fmt.Errorf("got %d, wanted 2", len(values))
+	}
+	id, err := values[0].ToString()
+	if err != nil {
+		return XMessage{}, err
+	}
+	keyValues, err := values[1].AsStrMap()
+	if err != nil {
+		return XMessage{}, err
+	}
+	return XMessage{
+		ID:        id,
+		KeyValues: keyValues,
+	}, nil
+}
+
+// AsXMessageSlice check if message is a redis array/set response, and convert to []XMessage
+func (m *RedisMessage) AsXMessageSlice() ([]XMessage, error) {
+	values, err := m.ToArray()
+	if err != nil {
+		return nil, err
+	}
+	msgs := make([]XMessage, 0, len(values))
+	for _, v := range values {
+		msg, err := v.AsXMessage()
+		if err != nil {
+			return nil, err
+		}
+		msgs = append(msgs, msg)
+	}
+	return msgs, nil
+
+}
+
 // AsMap check if message is a redis array/set response, and convert to map[string]RedisMessage
 func (m *RedisMessage) AsMap() (map[string]RedisMessage, error) {
 	values, err := m.ToArray()

message_test.go

@@ -170,6 +170,19 @@ func TestRedisResult(t *testing.T) {
 		}
 	})
 
+	t.Run("AsIntSlice", func(t *testing.T) {
+		if _, err := (RedisResult{err: errors.New("other")}).AsIntSlice(); err == nil {
+			t.Fatal("AsIntSlice not failed as expected")
+		}
+		if _, err := (RedisResult{val: RedisMessage{typ: '-'}}).AsIntSlice(); err == nil {
+			t.Fatal("AsIntSlice not failed as expected")
+		}
+		values := []RedisMessage{{integer: 2, typ: ':'}}
+		if ret, _ := (RedisResult{val: RedisMessage{typ: '*', values: values}}).AsIntSlice(); !reflect.DeepEqual(ret, []int64{2}) {
+			t.Fatal("AsIntSlice not get value as expected")
+		}
+	})
+
 	t.Run("AsMap", func(t *testing.T) {
 		if _, err := (RedisResult{err: errors.New("other")}).AsMap(); err == nil {
 			t.Fatal("AsMap not failed as expected")
@@ -373,6 +386,19 @@ func TestRedisMessage(t *testing.T) {
 		(&RedisMessage{typ: 't'}).AsStrSlice()
 	})
 
+	t.Run("AsIntSlice", func(t *testing.T) {
+		if _, err := (&RedisMessage{typ: '_'}).AsIntSlice(); err == nil {
+			t.Fatal("AsIntSlice not failed as expected")
+		}
+
+		defer func() {
+			if !strings.Contains(recover().(string), "redis message type t is not a array") {
+				t.Fatal("AsIntSlice not panic as expected")
+			}
+		}()
+		(&RedisMessage{typ: 't'}).AsIntSlice()
+	})
+
 	t.Run("AsMap", func(t *testing.T) {
 		if _, err := (&RedisMessage{typ: '_'}).AsMap(); err == nil {
 			t.Fatal("AsMap not failed as expected")