Method LRange

engine/grpc/client/list.go:225–266

(key string, start, stop int)

}

func (c *Client) LRange(key string, start, stop int) ([]interface{}, error) {
	client, err := newListGrpcClient(c.Addr)
	if err != nil {
		return nil, errors.New("new grpc client error: " + err.Error())
	}

	req := &glist.GListLRangeRequest{
		Key:   key,
		Start: int32(start),
		Stop:  int32(stop),
	}

	resp, err := client.LRange(context.Background(), req)
	if err != nil {
		return nil, errors.New("client LRange failed: " + err.Error())
	}

	// Convert the response to a slice of interface{} based on the gRPC response
	var values []interface{}
	for _, val := range resp.Values {
		switch v := val.Value.(type) {
		case *glist.Value_StringValue:
			values = append(values, v.StringValue)
		case *glist.Value_Int32Value:
			values = append(values, v.Int32Value)
		case *glist.Value_Int64Value:
			values = append(values, v.Int64Value)
		case *glist.Value_Float32Value:
			values = append(values, v.Float32Value)
		case *glist.Value_Float64Value:
			values = append(values, v.Float64Value)
		case *glist.Value_BoolValue:
			values = append(values, v.BoolValue)
		case *glist.Value_BytesValue:
			values = append(values, v.BytesValue)
		default:
			return nil, errors.New("unknown value type")
		}
	}

	return values, nil
}

func (c *Client) LLen(key string) (int32, error) {
	client, err := newListGrpcClient(c.Addr)