feature(pkg): modify

add func, remove rediss

README.md

@@ -16,7 +16,6 @@
 |[nets](https://github.com/pyihe/go-pkg/tree/master/nets)|网络相关|
 |[prt](https://github.com/pyihe/go-pkg/tree/master/ptr)|基础数据类型指针|
 |[rands](https://github.com/pyihe/go-pkg/tree/master/rands)|随机函数相关|
-|[redis](https://github.com/pyihe/go-pkg/tree/master/redis)|redis相关|
 |[snowflakes](https://github.com/pyihe/go-pkg/tree/master/snowflakes)|snowflake相关|
 |[sorts](https://github.com/pyihe/go-pkg/tree/master/sorts)|排序相关|
 |[strings](https://github.com/pyihe/go-pkg/tree/master/strings)|字符串相关|

errors/error.go

@@ -1,5 +1,7 @@
 package errors
 
+import "fmt"
+
 type Error struct {
 	err  string
 	code int32
@@ -16,7 +18,10 @@ func New(err string, codes ...int32) error {
 }
 
 func (e *Error) Error() (err string) {
-	return e.err
+	if e.code == 0 {
+		return e.err
+	}
+	return fmt.Sprintf("%d-%s", e.code, e.err)
 }
 
 func (e *Error) Code() int32 {

maths/math.go

@@ -62,3 +62,7 @@ func Abs(n int) int {
 	}
 	return n
 }
+
+func Even(m int) bool {
+	return m%2 == 0
+}

rediss/conn.go

@@ -1,426 +0,0 @@
-package rediss
-
-import (
-	"github.com/garyburd/redigo/redis"
-	"github.com/pyihe/go-pkg/errors"
-	"github.com/pyihe/go-pkg/serialize"
-)
-
-var (
-	ErrInvalidKey      = errors.New("invalid key")
-	ErrInvalidEncoder  = errors.New("not figure encoder")
-	ErrInvalidConn     = errors.New("invalid redis conn")
-	ErrInvalidParamNum = errors.New("invalid param num")
-)
-
-type myRedisConn struct {
-	conn    redis.Conn //redis连接池
-	encoder serialize.Serializer
-	prefix  string
-}
-
-func (conn *myRedisConn) checkKey(key string) (string, error) {
-	if len(key) == 0 {
-		return "", ErrInvalidKey
-	}
-	key = conn.prefix + key
-	return key, nil
-}
-
-func (conn *myRedisConn) Close() error {
-	if conn.conn != nil {
-		return conn.conn.Close()
-	}
-	return ErrInvalidConn
-}
-
-/*****************************string操作**********************************/
-//获取指定模式的key
-func (conn *myRedisConn) getKeys(pattern string) (keys []string, err error) {
-	if pattern == "" {
-		pattern = conn.prefix + "*"
-	}
-
-	keys, err = redis.Strings(conn.conn.Do("KEYS", pattern))
-	return keys, err
-}
-
-//string
-func (conn *myRedisConn) getString(key string) (value string, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return "", err
-	}
-	value, err = redis.String(conn.conn.Do("GET", key))
-	if err != nil {
-		if err == redis.ErrNil {
-			err = nil
-		}
-		return value, err
-	}
-	return value, err
-}
-
-func (conn *myRedisConn) setString(key, value string) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	_, err = redis.String(conn.conn.Do("SET", key, value))
-	return err
-}
-
-//[]byte
-func (conn *myRedisConn) getBytes(key string) (value []byte, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	value, err = redis.Bytes(conn.conn.Do("GET", key))
-	if err != nil {
-		if err == redis.ErrNil {
-			err = nil
-		}
-	}
-	return value, err
-}
-
-//
-func (conn *myRedisConn) setBytes(key string, value []byte) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-
-	_, err = redis.String(conn.conn.Do("SET", key, value))
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-//int
-func (conn *myRedisConn) getInt(key string) (value int, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return 0, err
-	}
-	value, err = redis.Int(conn.conn.Do("GET", key))
-	if err == redis.ErrNil {
-		err = nil
-	}
-	return value, err
-}
-
-func (conn *myRedisConn) getInt64(key string) (value int64, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return 0, err
-	}
-	value, err = redis.Int64(conn.conn.Do("GET", key))
-	if err == redis.ErrNil {
-		err = nil
-	}
-	return value, err
-}
-
-func (conn *myRedisConn) setInt(key string, value int64) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	_, err = redis.String(conn.conn.Do("SET", key, value))
-	return err
-}
-
-//struct
-func (conn *myRedisConn) getStruct(key string, data interface{}) (err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	bytes, err := redis.Bytes(conn.conn.Do("GET", key))
-	if err == redis.ErrNil {
-		err = nil
-		return err
-	}
-	if err != nil {
-		return err
-	}
-	err = conn.encoder.Decode(bytes, data)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (conn *myRedisConn) setStruct(key string, data interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if conn.encoder == nil {
-		return ErrInvalidEncoder
-	}
-	bytes, err := conn.encoder.Encode(data)
-	if err != nil {
-		return err
-	}
-	_, err = redis.String(conn.conn.Do("SET", key, bytes))
-	return err
-}
-
-func (conn *myRedisConn) del(key string) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	_, err = redis.String(conn.conn.Do("DEL", key))
-	return err
-}
-
-/******************************set操作*********************************/
-//往key对应的set添加元素
-func (conn *myRedisConn) sAdd(key string, members ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	_, err = conn.conn.Do("MULTI")
-	if err != nil {
-		return err
-	}
-	for _, m := range members {
-		_, err = conn.conn.Do("SADD", key, m)
-		if err != nil {
-			return err
-		}
-	}
-	_, err = conn.conn.Do("EXEC")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-//判断元素是否为set的元素
-func (conn *myRedisConn) sIsMember(key string, member interface{}) (bool, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return false, err
-	}
-	result, err := redis.Int(conn.conn.Do("SISMEMBER", key, member))
-	if err != nil {
-		if err == redis.ErrNil {
-			err = nil
-		}
-		return false, err
-	}
-	return result == 1, err
-}
-
-//随机从集合中获取元素
-func (conn *myRedisConn) sRandMember(key string, count uint) (value []interface{}, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	value, err = redis.Values(conn.conn.Do("SRANDMEMBER", key, count))
-	return
-}
-
-//返回集合中的元素数量
-func (conn *myRedisConn) sCARD(key string) (int, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return 0, err
-	}
-	result, err := redis.Int(conn.conn.Do("SCARD", key))
-	if err != nil {
-		if err == redis.ErrNil {
-			err = nil
-		}
-	}
-	return result, err
-}
-
-//返回集合中的所有元素
-func (conn *myRedisConn) sMembers(key string) ([]interface{}, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	result, err := redis.Values(conn.conn.Do("SMEMBERS", key))
-	if err != nil {
-		if err == redis.ErrNil {
-			err = nil
-		}
-	}
-	return result, err
-}
-
-/*****************************hash操作**********************************/
-func (conn *myRedisConn) hSet(key, field string, value interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	_, err = conn.conn.Do("HSET", key, field, value)
-	return err
-}
-
-//获取指定域的值
-func (conn *myRedisConn) hGet(key, field string) ([]byte, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	result, err := redis.Bytes(conn.conn.Do("HGET", key, field))
-	if err == redis.ErrNil {
-		err = nil
-	}
-	return result, err
-}
-
-//返回hash中所有的域
-func (conn *myRedisConn) hKeys(key string) (keys []string, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	keys, err = redis.Strings(conn.conn.Do("HKEYS", key))
-	return keys, err
-}
-
-//返回key对应的所有域和值
-func (conn *myRedisConn) hGetAll(key string) (value []interface{}, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	value, err = redis.Values(conn.conn.Do("HGETALL", key))
-	return value, err
-}
-
-//设置多对field-value
-func (conn *myRedisConn) hMset(key string, fields ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if len(fields)%2 != 0 {
-		return ErrInvalidParamNum
-	}
-	_, err = conn.conn.Do("MULTI")
-	if err != nil {
-		return err
-	}
-	var field, value interface{}
-	for i, v := range fields {
-		if i%2 != 0 {
-			value = v
-		} else {
-			field = v
-		}
-		_, err = redis.String(conn.conn.Do("HMSET", key, field, value))
-		if err != nil {
-			break
-		}
-	}
-	_, execErr := conn.conn.Do("EXEC")
-	return execErr
-}
-
-//删除
-func (conn *myRedisConn) hDel(key string, field string) (num int, err error) {
-	if key, err = conn.checkKey(key); err != nil {
-		return 0, err
-	}
-	num, err = redis.Int(conn.conn.Do("HDEL", key, field))
-	return num, err
-}
-
-/*****************************list操作**********************************/
-//将value插入到list头部
-func (conn *myRedisConn) lpush(key string, values ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if len(values) > 0 {
-		for _, v := range values {
-			_, err := redis.String(conn.conn.Do("LPUSH", key, v))
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (conn *myRedisConn) lpushx(key string, values ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if len(values) > 0 {
-		for _, v := range values {
-			_, err := redis.String(conn.conn.Do("LPUSHX", key, v))
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func (conn *myRedisConn) rpush(key string, values ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if len(values) > 0 {
-		for _, v := range values {
-			_, err := redis.String(conn.conn.Do("RPUSH", key, v))
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (conn *myRedisConn) rpushx(key string, values ...interface{}) error {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return err
-	}
-	if len(values) > 0 {
-		for _, v := range values {
-			_, err := redis.String(conn.conn.Do("RPUSHX", key, v))
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-//移除列表的头元素，及左边的那个元素
-func (conn *myRedisConn) lpop(key string) ([]byte, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	result, err := redis.Bytes(conn.conn.Do("LPOP", key))
-	if err == redis.ErrNil {
-		err = nil
-	}
-	return result, err
-}
-
-func (conn *myRedisConn) rpop(key string) ([]byte, error) {
-	var err error
-	if key, err = conn.checkKey(key); err != nil {
-		return nil, err
-	}
-	result, err := redis.Bytes(conn.conn.Do("RPOP", key))
-	if err == redis.ErrNil {
-		err = nil
-	}
-	return result, err
-}

rediss/hash.go

@@ -1,31 +0,0 @@
-package rediss
-
-func (conn *myRedisConn) HGet(key string, field string) ([]byte, error) {
-	value, err := conn.hGet(key, field)
-	return value, err
-}
-
-func (conn *myRedisConn) HSet(key string, field string, value interface{}) error {
-	err := conn.hSet(key, field, value)
-	return err
-}
-
-func (conn *myRedisConn) HGetAll(key string) ([]interface{}, error) {
-	result, err := conn.hGetAll(key)
-	return result, err
-}
-
-func (conn *myRedisConn) HKeys(key string) ([]string, error) {
-	keys, err := conn.hKeys(key)
-	return keys, err
-}
-
-func (conn *myRedisConn) HMset(key string, fieldValues ...interface{}) error {
-	err := conn.hMset(key, fieldValues...)
-	return err
-}
-
-func (conn *myRedisConn) HDel(key, field string) (int, error) {
-	num, err := conn.hDel(key, field)
-	return num, err
-}

rediss/list.go

@@ -1,31 +0,0 @@
-package rediss
-
-func (conn *myRedisConn) RPush(key string, values ...interface{}) error {
-	err := conn.rpush(key, values...)
-	return err
-}
-
-func (conn *myRedisConn) RPushX(key string, values ...interface{}) error {
-	err := conn.rpushx(key, values...)
-	return err
-}
-
-func (conn *myRedisConn) LPush(key string, values ...interface{}) error {
-	err := conn.lpush(key, values...)
-	return err
-}
-
-func (conn *myRedisConn) LPushX(key string, values ...interface{}) error {
-	err := conn.lpushx(key, values...)
-	return err
-}
-
-func (conn *myRedisConn) LPop(key string) (result []byte, err error) {
-	result, err = conn.lpop(key)
-	return result, err
-}
-
-func (conn *myRedisConn) RPop(key string) (result []byte, err error) {
-	result, err = conn.rpop(key)
-	return result, err
-}

rediss/pool.go

@@ -1,151 +0,0 @@
-package rediss
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/pyihe/go-pkg/serialize"
-
-	"github.com/garyburd/redigo/redis"
-)
-
-type RedisConn interface {
-	Close() error
-	//string
-	GetKeys(pattern string) (keys []string, err error)
-	GetString(key string) (value string, err error)
-	SetString(key, value string) error
-	GetBytes(key string) (value []byte, err error)
-	SetBytes(key string, value []byte) error
-	GetInt(key string) (value int, err error)
-	GetInt64(key string) (value int64, err error)
-	SetInt(key string, value int64) error
-	GetStruct(key string, data interface{}) (err error)
-	SetStruct(key string, data interface{}) error
-
-	//hash
-	HGet(key string, field string) ([]byte, error)
-	HSet(key string, field string, value interface{}) error
-	HGetAll(key string) ([]interface{}, error)
-	HKeys(key string) ([]string, error)
-	HMset(key string, fieldValues ...interface{}) error
-	HDel(key, field string) (int, error)
-
-	//list
-	RPush(key string, values ...interface{}) error
-	RPushX(key string, values ...interface{}) error
-	LPush(key string, values ...interface{}) error
-	LPushX(key string, values ...interface{}) error
-	LPop(key string) (result []byte, err error)
-	RPop(key string) (result []byte, err error)
-
-	//set
-	SADD(key string, members ...interface{}) error
-	SIsMember(key string, member interface{}) (bool, error)
-	SCard(key string) (int, error)
-	Smembers(key string) ([]interface{}, error)
-}
-
-type RedisPool interface {
-	Get() (RedisConn, error)
-	Close() error
-}
-
-type myPool struct {
-	prefix  string
-	net     string
-	addr    string
-	pass    string
-	db      int
-	p       *redis.Pool
-	encoder serialize.Serializer
-}
-
-type InitOptions func(m *myPool)
-
-func WithEncoding(encoder serialize.Serializer) InitOptions {
-	return func(m *myPool) {
-		m.encoder = encoder
-	}
-}
-
-func WithPrefix(prefix string) InitOptions {
-	return func(m *myPool) {
-		m.prefix = prefix
-	}
-}
-
-func WithNetWork(net string) InitOptions {
-	return func(m *myPool) {
-		m.net = net
-	}
-}
-
-func WithAddr(addr string) InitOptions {
-	return func(m *myPool) {
-		m.addr = addr
-	}
-}
-
-func WithPass(pass string) InitOptions {
-	return func(m *myPool) {
-		m.pass = pass
-	}
-}
-
-func WithDBIndex(db int) InitOptions {
-	return func(m *myPool) {
-		m.db = db
-	}
-}
-
-func NewPool(opts ...InitOptions) (RedisPool, error) {
-	defaultPool := &myPool{}
-	for _, op := range opts {
-		op(defaultPool)
-	}
-	if defaultPool.addr == "" {
-		return nil, fmt.Errorf("no rediss address")
-	}
-	if defaultPool.db == 0 {
-		defaultPool.db = 1
-	}
-	if defaultPool.net == "" {
-		defaultPool.net = "tcps"
-	}
-	defaultPool.p = &redis.Pool{
-		Dial: func() (conn redis.Conn, e error) {
-			return redis.Dial(defaultPool.net, defaultPool.addr, redis.DialDatabase(defaultPool.db), redis.DialPassword(defaultPool.pass))
-		},
-		MaxIdle:     10,
-		MaxActive:   0,
-		IdleTimeout: 120 * time.Second,
-		Wait:        true,
-		TestOnBorrow: func(c redis.Conn, t time.Time) error {
-			_, err := c.Do("PING")
-			return err
-		},
-	}
-	return defaultPool, nil
-}
-
-func (m *myPool) Get() (RedisConn, error) {
-	conn := m.p.Get()
-	if conn == nil {
-		return nil, fmt.Errorf("unavailable conn")
-	}
-	_, err := conn.Do("PING")
-	if err != nil {
-		return nil, err
-	}
-	c := &myRedisConn{
-		prefix:  m.prefix,
-		conn:    conn,
-		encoder: m.encoder,
-	}
-	return c, nil
-}
-
-func (m *myPool) Close() error {
-	return m.p.Close()
-}

rediss/set.go

@@ -1,21 +0,0 @@
-package rediss
-
-func (conn *myRedisConn) SADD(key string, members ...interface{}) error {
-	err := conn.sAdd(key, members...)
-	return err
-}
-
-func (conn *myRedisConn) SIsMember(key string, member interface{}) (bool, error) {
-	result, err := conn.sIsMember(key, member)
-	return result, err
-}
-
-func (conn *myRedisConn) SCard(key string) (int, error) {
-	count, err := conn.sCARD(key)
-	return count, err
-}
-
-func (conn *myRedisConn) Smembers(key string) ([]interface{}, error) {
-	result, err := conn.sMembers(key)
-	return result, err
-}

rediss/string.go

@@ -1,48 +0,0 @@
-package rediss
-
-func (conn *myRedisConn) GetKeys(pattern string) (keys []string, err error) {
-	keys, err = conn.getKeys(pattern)
-	return
-}
-
-func (conn *myRedisConn) GetString(key string) (value string, err error) {
-	return conn.getString(key)
-}
-
-func (conn *myRedisConn) SetString(key, value string) error {
-	return conn.setString(key, value)
-}
-
-func (conn *myRedisConn) GetBytes(key string) (value []byte, err error) {
-	value, err = conn.getBytes(key)
-	return value, err
-}
-
-func (conn *myRedisConn) SetBytes(key string, value []byte) error {
-	return conn.setBytes(key, value)
-}
-
-func (conn *myRedisConn) GetInt(key string) (value int, err error) {
-	value, err = conn.getInt(key)
-	return value, err
-}
-
-func (conn *myRedisConn) GetInt64(key string) (value int64, err error) {
-	value, err = conn.getInt64(key)
-	return value, err
-}
-
-func (conn *myRedisConn) SetInt(key string, value int64) error {
-	err := conn.setInt(key, value)
-	return err
-}
-
-func (conn *myRedisConn) GetStruct(key string, data interface{}) (err error) {
-	err = conn.getStruct(key, data)
-	return err
-}
-
-func (conn *myRedisConn) SetStruct(key string, data interface{}) error {
-	err := conn.setStruct(key, data)
-	return err
-}