[cache/v1/v2] make fields private

Author: Christos Kotsis

cache/v1/v1.go

@@ -5,58 +5,162 @@ package v1
 // for condition, while []Keys is used by path discovery methods
 // to keep track and derive the right path.
 type Cache struct {
-	V1, V2     interface{}
-	V3         []interface{}
-	B          []byte
-	E          error
-	C1, C2, C3 int
-	Keys       []string
+	v1, v2     interface{}
+	v3         []interface{}
+	b          []byte
+	e          error
+	c1, c2, c3 int
+	keys       []string
 }
 
 // NewCacheFactory for creating a new Cache
 func NewCacheFactory() Cache {
 	cache := Cache{
-		V3:   make([]interface{}, 0),
-		B:    make([]byte, 0),
-		Keys: make([]string, 0),
+		v3:   make([]interface{}, 0),
+		b:    make([]byte, 0),
+		keys: make([]string, 0),
 	}
 	return cache
 }
 
-// GetError returns cache error field
-func (c *Cache) GetError() error {
-	return c.E
+// E can be used to set or get e. If no argument is passed
+// the method returns e value. If an argument is passed, the method
+// sets e's value to that of the arguments
+func (c *Cache) E(e ...error) error {
+	if len(e) > 0 {
+		c.e = e[0]
+	}
+	return c.e
 }
 
 // Clear for clearing the cache and setting all
 // content to nil
 func (c *Cache) Clear() {
-	c.V1, c.V2 = nil, nil
-	c.V3 = make([]interface{}, 0)
-	c.C1, c.C2, c.C3 = 0, 0, 0
-	c.B = make([]byte, 0)
-	c.E = nil
-	c.Keys = make([]string, 0)
+	c.v1, c.v2 = nil, nil
+	c.v3 = make([]interface{}, 0)
+	c.c1, c.c2, c.c3 = 0, 0, 0
+	c.b = make([]byte, 0)
+	c.e = nil
+	c.keys = make([]string, 0)
 }
 
 // DropLastKey removes the last key added from the list
 func (c *Cache) DropLastKey() {
-	if len(c.Keys) > 0 {
-		c.Keys = c.Keys[:len(c.Keys)-1]
+	if len(c.keys) > 0 {
+		c.keys = c.keys[:len(c.keys)-1]
 	}
 }
 
 // DropKeys removes all keys from the list
 func (c *Cache) DropKeys() {
-	c.Keys = make([]string, 0)
+	c.keys = make([]string, 0)
 }
 
 // AddKey for appending a new Key to cache
 func (c *Cache) AddKey(k string) {
-	c.Keys = append(c.Keys, k)
+	c.keys = append(c.keys, k)
 }
 
 // GetKeys returns Cache.Keys
 func (c *Cache) GetKeys() []string {
-	return c.Keys
+	return c.keys
+}
+
+// DropV3 removes all keys from the list
+func (c *Cache) DropV3() {
+	c.v3 = make([]interface{}, 0)
+}
+
+// V3 returns Cache.V3
+func (c *Cache) V3(v ...interface{}) []interface{} {
+	if len(v) > 0 {
+		c.v3 = append(c.v3, v[0])
+	}
+	return c.v3
+}
+
+// C1 can be used to set or get c1. If no argument is passed
+// the method returns c1 value. If an argument is passed, the method
+// sets c1's value to that of the arguments
+func (c *Cache) C1(i ...int) int {
+	if len(i) > 0 {
+		c.c1 = i[0]
+	}
+	return c.c1
+}
+
+// C2 can be used to set or get c2. If no argument is passed
+// the method returns c2 value. If an argument is passed, the method
+// sets c2's value to that of the arguments
+func (c *Cache) C2(i ...int) int {
+	if len(i) > 0 {
+		c.c2 = i[0]
+	}
+	return c.c2
+}
+
+// C3 can be used to set or get c3. If no argument is passed
+// the method returns c3 value. If an argument is passed, the method
+// sets c3's value to that of the arguments
+func (c *Cache) C3(i ...int) int {
+	if len(i) > 0 {
+		c.c3 = i[0]
+	}
+	return c.c3
+}
+
+// V1 can be used to set or get v1. If no argument is passed
+// the method returns v1 value. If an argument is passed, the method
+// sets v1's value to that of the arguments
+func (c *Cache) V1(v ...interface{}) interface{} {
+	if len(v) > 0 {
+		c.v1 = v[0]
+	}
+	return c.v1
+}
+
+// V2 can be used to set or get v2. If no argument is passed
+// the method returns v2 value. If an argument is passed, the method
+// sets v2's value to that of the arguments
+func (c *Cache) V2(v ...interface{}) interface{} {
+	if len(v) > 0 {
+		c.v2 = v[0]
+	}
+
+	return c.v2
+}
+
+// B can be used to set or get b. If no argument is passed
+// the method returns b value. If an argument is passed, the method
+// sets b's value to that of the arguments
+func (c *Cache) B(b ...[]byte) []byte {
+	if len(b) > 0 {
+		c.b = b[0]
+	}
+
+	return c.b
+}
+
+// BE expects 2 inputs, a byte array and an error.
+// If byte array is not nil, b will be set to the
+// value of the new byte array. Error is returned
+// with the new/old byte array at the end always
+func (c *Cache) BE(b []byte, e error) error {
+	if b != nil {
+		c.b = b
+	}
+
+	return e
+}
+
+// V1E expects 2 inputs, a byte array and an error.
+// If byte array is not nil, b will be set to the
+// value of the new byte array. Error is returned
+// with the new/old byte array at the end always
+func (c *Cache) V1E(v interface{}, e error) error {
+	if v != nil {
+		c.v1 = v
+	}
+
+	return e
 }

cache/v2/v2.go

@@ -2,30 +2,28 @@ package v1
 
 // Cache hosts results from SQL methods
 type Cache struct {
-	KeysFound []string
-	Results   interface{}
+	v1 []string
 }
 
 // NewCacheFactory for creating a new Cache
 func NewCacheFactory() Cache {
 	cache := Cache{
-		KeysFound: make([]string, 0),
+		v1: make([]string, 0),
 	}
 	return cache
 }
 
 // Clear for clearing the cache
 func (c *Cache) Clear() {
-	c.Results = nil
-	c.KeysFound = make([]string, 0)
+	c.v1 = make([]string, 0)
 }
 
 // AddKey for appending a new Key to cache
 func (c *Cache) AddKey(k string) {
-	c.KeysFound = append(c.KeysFound, k)
+	c.v1 = append(c.v1, k)
 }
 
 // GetKeys returns Cache.KeysFound
 func (c *Cache) GetKeys() []string {
-	return c.KeysFound
+	return c.v1
 }

db/convert.go

@@ -38,20 +38,20 @@ func (a *AssertData) Clear() {
 
 // GetError returns the any error set to AssertData
 func (a *AssertData) GetError() error {
-	return a.cache.GetError()
+	return a.cache.E()
 }
 
 func (a *AssertData) setErr(e ...error) *AssertData {
 	if len(e) > 0 {
-		a.cache.E = e[0]
+		a.cache.E(e[0])
 	}
 	return a
 }
 
 // Input sets a data source that can be used for assertion
 func (a *AssertData) Input(o interface{}) *AssertData {
 	a.Clear()
-	a.cache.V1 = o
+	a.cache.V1(o)
 	return a
 }
 
@@ -61,7 +61,7 @@ func (a *AssertData) GetString() (string, error) {
 		return "", a.GetError()
 	}
 
-	s, isString := a.cache.V1.(string)
+	s, isString := a.cache.V1().(string)
 	if !isString {
 		a.setErr(wrapErr(notAType, "string"))
 		return "", a.GetError()
@@ -76,7 +76,7 @@ func (a *AssertData) GetInt() (int, error) {
 		return 0, a.GetError()
 	}
 
-	i, isInt := a.cache.V1.(int)
+	i, isInt := a.cache.V1().(int)
 	if !isInt {
 		a.setErr(wrapErr(notAType, "int"))
 		return 0, a.GetError()
@@ -91,12 +91,12 @@ func (a *AssertData) GetMap() (map[string]string, error) {
 		return nil, a.GetError()
 	}
 
-	a.cache.B, a.cache.E = yaml.Marshal(a.cache.V1)
+	a.cache.E(a.cache.BE(yaml.Marshal(a.cache.V1())))
 	if a.GetError() != nil {
 		return nil, a.GetError()
 	}
 
-	a.cache.E = yaml.Unmarshal(a.cache.B, &a.d0)
+	a.cache.E(yaml.Unmarshal(a.cache.B(), &a.d0))
 	if a.GetError() != nil {
 		return nil, a.GetError()
 	}
@@ -109,18 +109,18 @@ func (a *AssertData) GetArray() ([]string, error) {
 		return nil, a.GetError()
 	}
 
-	_, isArray := a.cache.V1.([]interface{})
+	_, isArray := a.cache.V1().([]interface{})
 	if !isArray {
 		a.setErr(wrapErr(notArrayObj))
 		return nil, a.GetError()
 	}
 
-	a.cache.B, a.cache.E = yaml.Marshal(a.cache.V1)
+	a.cache.E(a.cache.BE(yaml.Marshal(a.cache.V1())))
 	if a.GetError() != nil {
 		return nil, a.GetError()
 	}
 
-	a.cache.E = yaml.Unmarshal(a.cache.B, &a.s1)
+	a.cache.E(yaml.Unmarshal(a.cache.B(), &a.s1))
 	if a.GetError() != nil {
 		return nil, a.GetError()
 	}
@@ -135,12 +135,12 @@ func (a *AssertData) Key(k string) *AssertData {
 		return a
 	}
 
-	_, isMap := a.cache.V1.(map[interface{}]interface{})
+	_, isMap := a.cache.V1().(map[interface{}]interface{})
 	if !isMap {
 		return a.setErr(wrapErr(notAMap))
 	}
 
-	a.cache.V1 = a.cache.V1.(map[interface{}]interface{})[k]
+	a.cache.V1(a.cache.V1().(map[interface{}]interface{})[k])
 
 	return a
 }
@@ -151,11 +151,11 @@ func (a *AssertData) Index(i int) *AssertData {
 		return a
 	}
 
-	_, isArray := a.cache.V1.([]interface{})
+	_, isArray := a.cache.V1().([]interface{})
 	if !isArray {
 		return a.setErr(wrapErr(notArrayObj))
 	}
-	a.cache.V1 = a.cache.V1.([]interface{})[i]
+	a.cache.V1(a.cache.V1().([]interface{})[i])
 
 	return a
 }

db/sql.go

@@ -218,20 +218,20 @@ func (s *SQL) get(k string, o interface{}) ([]string, error) {
 	var key string
 
 	s.Clear()
-	s.Cache.V1, err = copyMap(o)
+	err = s.Cache.V1E(copyMap(o))
 	if err != nil {
 		return nil, wrapErr(err)
 	}
 
 	for {
-		if _, found := s.getObj(k, s.Cache.V1); !found {
+		if _, found := s.getObj(k, s.Cache.V1()); !found {
 			break
 		}
 
 		key = strings.Join(s.Cache.GetKeys(), ".")
 		s.Query.AddKey(key)
 
-		if err := s.delPath(key, s.Cache.V1); err != nil {
+		if err := s.delPath(key, s.Cache.V1()); err != nil {
 			return s.Query.GetKeys(), wrapErr(err)
 		}
 		s.Cache.DropKeys()
@@ -257,20 +257,20 @@ func (s *SQL) getFirst(k string, o interface{}) (interface{}, error) {
 		return nil, wrapErr(err)
 	}
 
-	s.Cache.C1 = len(keySlice)
+	s.Cache.C1(len(keySlice))
 	if len(keys) == 1 {
 		path, err := s.getPath(keySlice, o)
 		return path, wrapErr(err)
 	}
 
 	for i, key := range keys[1:] {
-		if len(strings.Split(key, ".")) < s.Cache.C1 {
-			s.Cache.C1 = len(strings.Split(key, "."))
-			s.Cache.C2 = i + 1
+		if len(strings.Split(key, ".")) < s.Cache.C1() {
+			s.Cache.C1(len(strings.Split(key, ".")))
+			s.Cache.C2(i + 1)
 		}
 	}
 
-	path, err := s.getPath(strings.Split(keys[s.Cache.C2], "."), o)
+	path, err := s.getPath(strings.Split(keys[s.Cache.C2()], "."), o)
 	return path, wrapErr(err)
 }