internal/sdlgo/sdl.go

   1 /*
   2    Copyright (c) 2019 AT&T Intellectual Property.
   3    Copyright (c) 2018-2019 Nokia.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 */
  17
  18 package sdlgo
  19
  20 import (
  21         "reflect"
  22         "strings"
  23
  24         "gerrit.oran-osc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
  25 )
  26
  27 type Idatabase interface {
  28         MSet(pairs ...interface{}) error
  29         MGet(keys []string) ([]interface{}, error)
  30         Close() error
  31         Del(keys []string) error
  32         Keys(key string) ([]string, error)
  33 }
  34
  35 type SdlInstance struct {
  36         NameSpace string
  37         NsPrefix  string
  38         Idatabase
  39 }
  40
  41 func Create(NameSpace string) *SdlInstance {
  42         db := sdlgoredis.Create()
  43         s := SdlInstance{
  44                 NameSpace: NameSpace,
  45                 NsPrefix:  "{" + NameSpace + "},",
  46                 Idatabase: db,
  47         }
  48
  49         return &s
  50 }
  51
  52 func (s *SdlInstance) Close() error {
  53         return s.Close()
  54 }
  55
  56 func (s *SdlInstance) setNamespaceToKeys(pairs ...interface{}) []interface{} {
  57         var retVal []interface{}
  58         for i, v := range pairs {
  59                 if i%2 == 0 {
  60                         reflectType := reflect.TypeOf(v)
  61                         switch reflectType.Kind() {
  62                         case reflect.Slice:
  63                                 x := reflect.ValueOf(v)
  64                                 for i2 := 0; i2 < x.Len(); i2++ {
  65                                         if i2%2 == 0 {
  66                                                 retVal = append(retVal, s.NsPrefix+x.Index(i2).Interface().(string))
  67                                         } else {
  68                                                 retVal = append(retVal, x.Index(i2).Interface())
  69                                         }
  70                                 }
  71                         case reflect.Array:
  72                                 x := reflect.ValueOf(v)
  73                                 for i2 := 0; i2 < x.Len(); i2++ {
  74                                         if i2%2 == 0 {
  75                                                 retVal = append(retVal, s.NsPrefix+x.Index(i2).Interface().(string))
  76                                         } else {
  77                                                 retVal = append(retVal, x.Index(i2).Interface())
  78                                         }
  79                                 }
  80                         default:
  81                                 retVal = append(retVal, s.NsPrefix+v.(string))
  82                         }
  83                 } else {
  84                         retVal = append(retVal, v)
  85                 }
  86         }
  87         return retVal
  88 }
  89
  90 func (s *SdlInstance) Set(pairs ...interface{}) error {
  91         if len(pairs) == 0 {
  92                 return nil
  93         }
  94
  95         keyAndData := s.setNamespaceToKeys(pairs...)
  96         err := s.MSet(keyAndData...)
  97         return err
  98 }
  99
 100 func (s *SdlInstance) Get(keys []string) (map[string]interface{}, error) {
 101         m := make(map[string]interface{})
 102         if len(keys) == 0 {
 103                 return m, nil
 104         }
 105
 106         var keysWithNs []string
 107         for _, v := range keys {
 108                 keysWithNs = append(keysWithNs, s.NsPrefix+v)
 109         }
 110         val, err := s.MGet(keysWithNs)
 111         if err != nil {
 112                 return m, err
 113         }
 114         for i, v := range val {
 115                 m[keys[i]] = v
 116         }
 117         return m, err
 118 }
 119
 120 func (s *SdlInstance) SetIf(key string, oldData, newData interface{}) {
 121         panic("SetIf not implemented\n")
 122 }
 123
 124 func (s *SdlInstance) SetIfiNotExists(key string, data interface{}) {
 125         panic("SetIfiNotExists not implemented\n")
 126 }
 127
 128 func (s *SdlInstance) Remove(keys []string) error {
 129         if len(keys) == 0 {
 130                 return nil
 131         }
 132
 133         var keysWithNs []string
 134         for _, v := range keys {
 135                 keysWithNs = append(keysWithNs, s.NsPrefix+v)
 136         }
 137         err := s.Del(keysWithNs)
 138         return err
 139 }
 140
 141 func (s *SdlInstance) RemoveIf(key string, data interface{}) {
 142         panic("RemoveIf not implemented\n")
 143 }
 144
 145 func (s *SdlInstance) GetAll() ([]string, error) {
 146         keys, err := s.Keys(s.NsPrefix + "*")
 147         var retVal []string = nil
 148         if err != nil {
 149                 return retVal, err
 150         }
 151         for _, v := range keys {
 152                 retVal = append(retVal, strings.Split(v, s.NsPrefix)[1])
 153         }
 154         return retVal, err
 155 }
 156
 157 func (s *SdlInstance) RemoveAll() error {
 158         keys, err := s.Keys(s.NsPrefix + "*")
 159         if err != nil {
 160                 return err
 161         }
 162         if keys != nil {
 163                 err = s.Del(keys)
 164         }
 165         return err
 166 }