p53841790
/
wheat-cache
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

feat(stringx): update dao stringx

This commit is contained in:
bandl 2021-10-27 23:15:26 +08:00
parent 1f85847243
commit 5642a00f61
1 changed files with 53 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
storage/dao/stringx.go
View File

@ -8,15 +8,15 @@ import (
) )
// stringx 相关的方法 // stringx 相关的方法
func (d *Dao) Set(key *proto.BaseKey, strVal string) (string, error) { func (d *Dao) Set(key *proto.BaseKey, strVal string) (*proto.SetResponse, error) {
value, ok := d.lru.Get(key) value, ok := d.lru.Get(key)
if ok { if ok {
if val, ok := value.(structure.StringXInterface); ok { if val, ok := value.(structure.StringXInterface); ok {
res, length := val.Set(strVal) res, length := val.Set(strVal)
d.lru.UpdateLruSize(length) d.lru.UpdateLruSize(length)
return res, nil return &proto.SetResponse{Result: res}, nil
} else { } else {
return "", errorx.New("the key:%s is not stringx type", key) return nil, errorx.New("the key:%s is not stringx type", key)
} }
} }
@ -25,161 +25,169 @@ func (d *Dao) Set(key *proto.BaseKey, strVal string) (string, error) {
result, _ := strValue.Set(strVal) result, _ := strValue.Set(strVal)
err := d.lru.Add(key, strValue) err := d.lru.Add(key, strValue)
if err != nil { if err != nil {
return "", err return nil, err
} }
return result, nil return &proto.SetResponse{Result: result}, nil
} }
func (d *Dao) Get(key *proto.BaseKey) (string, error) { func (d *Dao) Get(key *proto.BaseKey) (*proto.GetResponse, error) {
val, ok := d.lru.Get(key) val, ok := d.lru.Get(key)
if !ok { if !ok {
return "", errorx.NotKeyErr(key.Key) return nil, errorx.NotKeyErr(key.Key)
} }
strVal, ok := val.(structure.StringXInterface) strVal, ok := val.(structure.StringXInterface)
if !ok { if !ok {
return "", errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
return strVal.Get(), nil return &proto.GetResponse{Result: strVal.Get()}, nil
} }
func (d *Dao) Add(key *proto.BaseKey, renewal int32) (string, error) { func (d *Dao) Add(key *proto.BaseKey, renewal int32) (*proto.AddResponse, error) {
value, lruOk := d.lru.Get(key) value, lruOk := d.lru.Get(key)
if !lruOk { if !lruOk {
val := stringx.NewStringSingle() val := stringx.NewStringSingle()
res, err := val.Add(renewal) res, err := val.Add(renewal)
if err != nil { if err != nil {
return "", nil return nil, nil
} }
d.lru.Add(key, val) d.lru.Add(key, val)
return res, nil return &proto.AddResponse{Result: res}, nil
} }
strVal, ok := value.(structure.StringXInterface) strVal, ok := value.(structure.StringXInterface)
if !ok { if !ok {
return "", errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
res, err := strVal.Add(renewal) res, err := strVal.Add(renewal)
if err != nil { if err != nil {
return "", err return nil, err
} }
return res, nil return &proto.AddResponse{Result: res}, nil
} }
func (d *Dao) Reduce(key *proto.BaseKey, renewal int32) (string, error) { func (d *Dao) Reduce(key *proto.BaseKey, renewal int32) (*proto.ReduceResponse, error) {
value, lruOk := d.lru.Get(key) value, lruOk := d.lru.Get(key)
if !lruOk { if !lruOk {
val := stringx.NewStringSingle() val := stringx.NewStringSingle()
res, err := val.Reduce(renewal) res, err := val.Reduce(renewal)
if err != nil { if err != nil {
return "", nil return nil, err
} }
d.lru.Add(key, val) d.lru.Add(key, val)
return res, nil return &proto.ReduceResponse{Result: res}, nil
} }
strVal, ok := value.(structure.StringXInterface) strVal, ok := value.(structure.StringXInterface)
if !ok { if !ok {
return "", errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
res, err := strVal.Reduce(renewal) res, err := strVal.Reduce(renewal)
if err != nil { if err != nil {
return "", err return nil, err
} }
return res, nil return &proto.ReduceResponse{Result: res}, nil
} }
func (d *Dao) SetBit(key *proto.BaseKey, val bool, offer int32) error { func (d *Dao) SetBit(key *proto.BaseKey, val bool, offer int32) (*proto.SetBitResponse, error) {
value, lruOk := d.lru.Get(key) value, lruOk := d.lru.Get(key)
if !lruOk { if !lruOk {
valStr := stringx.NewStringSingle() valStr := stringx.NewStringSingle()
length := valStr.Setbit(offer, val) length := valStr.Setbit(offer, val)
d.lru.UpdateLruSize(length) d.lru.UpdateLruSize(length)
d.lru.Add(key, valStr) d.lru.Add(key, valStr)
return nil return &proto.SetBitResponse{}, nil
} }
strVal, ok := value.(structure.StringXInterface) strVal, ok := value.(structure.StringXInterface)
if !ok { if !ok {
return errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
length := strVal.Setbit(offer, val) length := strVal.Setbit(offer, val)
d.lru.UpdateLruSize(length) d.lru.UpdateLruSize(length)
return nil return &proto.SetBitResponse{}, nil
} }
func (d *Dao) GetBit(key *proto.BaseKey, offer int32) (bool, error) { func (d *Dao) GetBit(key *proto.BaseKey, offer int32) (*proto.GetBitResponse, error) {
value, lruOk := d.lru.Get(key) value, lruOk := d.lru.Get(key)
if !lruOk { if !lruOk {
return false, errorx.NotKeyErr(key.Key) return nil, errorx.NotKeyErr(key.Key)
} }
strVal, ok := value.(structure.StringXInterface) strVal, ok := value.(structure.StringXInterface)
if !ok { if !ok {
return false, errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
return strVal.Getbit(offer) res, err := strVal.Getbit(offer)
if err != nil {
return nil, err
}
return &proto.GetBitResponse{Val: res}, nil
} }
func (d *Dao) GetRange(key *proto.BaseKey, start, end int32) (string, error) { func (d *Dao) GetRange(key *proto.BaseKey, start, end int32) (*proto.GetRangeResponse, error) {
value, lruOk := d.lru.Get(key) value, lruOk := d.lru.Get(key)
if !lruOk { if !lruOk {
return "", errorx.NotKeyErr(key.Key) return nil, errorx.NotKeyErr(key.Key)
} }
strVal, ok := value.(structure.StringXInterface) strVal, ok := value.(structure.StringXInterface)
if !ok { if !ok {
return "", errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
return strVal.Getrange(start, end) res, err := strVal.Getrange(start, end)
if err != nil {
return nil, err
}
return &proto.GetRangeResponse{Result: res}, nil
} }
func (d *Dao) GetSet(key *proto.BaseKey, value string) (string, error) { func (d *Dao) GetSet(key *proto.BaseKey, value string) (*proto.GetSetResponse, error) {
val, ok := d.lru.Get(key) val, ok := d.lru.Get(key)
if !ok { if !ok {
return "", errorx.NotKeyErr(key.Key) return nil, errorx.NotKeyErr(key.Key)
} }
strVal, ok := val.(structure.StringXInterface) strVal, ok := val.(structure.StringXInterface)
if !ok { if !ok {
return "", errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
oldValue := strVal.Get() oldValue := strVal.Get()
_, updateLength := strVal.Set(value) _, updateLength := strVal.Set(value)
d.lru.UpdateLruSize(updateLength) d.lru.UpdateLruSize(updateLength)
return oldValue, nil return &proto.GetSetResponse{Result: oldValue}, nil
} }
func (d *Dao) StrLen(key *proto.BaseKey) (int32, error) { func (d *Dao) StrLen(key *proto.BaseKey) (*proto.StrLenResponse, error) {
val, ok := d.lru.Get(key) val, ok := d.lru.Get(key)
if !ok { if !ok {
return 0, errorx.NotKeyErr(key.Key) return nil, errorx.NotKeyErr(key.Key)
} }
strVal, ok := val.(structure.StringXInterface) strVal, ok := val.(structure.StringXInterface)
if !ok { if !ok {
return 0, errorx.DaoTypeErr("stringx") return nil, errorx.DaoTypeErr("stringx")
} }
return int32(strVal.GetLength()), nil return &proto.StrLenResponse{Length: int32(strVal.GetLength())}, nil
} }
func (d *Dao) Setnx(key *proto.BaseKey, val string) error { func (d *Dao) Setnx(key *proto.BaseKey, val string) (*proto.SetnxResponse, error) {
_, ok := d.lru.Get(key) _, ok := d.lru.Get(key)
if ok { if ok {
return errorx.New("the key already exists") return nil, errorx.New("the key already exists")
} }
strValue := stringx.NewStringSingle() strValue := stringx.NewStringSingle()
strValue.Set(val) strValue.Set(val)
err := d.lru.Add(key, strValue) err := d.lru.Add(key, strValue)
if err != nil { if err != nil {
return err return nil, err
} }
return nil return &proto.SetnxResponse{}, nil
} }