Merge branch 'master' of https://git.bullercodeworks.com/brian/boltease

bolteasable.go

@@ -1,189 +0,0 @@
-package boltease
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-type any interface{}
-
-func (b *DB) Load(path []string, dest any) error {
-	destValue := reflect.ValueOf(dest)
-	fmt.Println("Loading:", path, destValue)
-	if destValue.Kind() != reflect.Pointer {
-		return errors.New("Destination must be a pointer")
-	}
-	d := reflect.Indirect(destValue)
-	fmt.Println(">> d.Kind() ->", d.Kind())
-	if d.Kind() != reflect.Struct {
-		fmt.Println(">> Kind != Struct; GetForInterface")
-		path, name := path[:len(path)-1], path[len(path)-1]
-		return b.GetForInterface(path, name, dest)
-	}
-
-	entityType := reflect.TypeOf(dest).Elem()
-	var ret error
-	for i := 0; i < entityType.NumField(); i++ {
-		structFld := entityType.Field(i)
-		fldName := FieldName(structFld)
-		fmt.Println("Loading Field:", fldName, "->", structFld.Type.Kind())
-		switch structFld.Type.Kind() {
-		case reflect.Pointer, reflect.Struct:
-			fmt.Println("Getting Pointer or Struct")
-			var wrk interface{}
-			var wrkV reflect.Value
-			if structFld.Type.Kind() == reflect.Pointer {
-				fmt.Println("  It's a pointer to something")
-				wrkV = reflect.New(structFld.Type).Elem()
-			} else {
-				fmt.Println("  It's a struct itself")
-				wrkV = reflect.New(reflect.TypeOf(structFld))
-			}
-			wrk = wrkV.Interface()
-			fmt.Println("-> Recurse (struct)", reflect.TypeOf(wrk))
-			err := b.Load(append(path, fldName), &wrk)
-			if err != nil {
-				fmt.Println("-> -> Error loading.", err.Error())
-				if ret == nil {
-					ret = err
-				}
-			} else {
-				// Set the value
-				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
-			}
-
-		case reflect.String:
-			fmt.Println("Getting String")
-			var wrk string
-			err := b.GetForInterface(path, fldName, &wrk)
-			if err != nil {
-				if ret == nil {
-					ret = err
-				}
-			} else {
-				// Set the value
-				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
-			}
-
-		case reflect.Bool:
-			fmt.Println("Getting Boolean")
-			var wrk bool
-			err := b.GetForInterface(path, fldName, &wrk)
-			if err != nil {
-				if ret == nil {
-					ret = err
-				}
-			} else {
-				// Set the value
-				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
-			}
-
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			fmt.Println("Getting Integer")
-			var wrk int
-			err := b.GetForInterface(path, fldName, &wrk)
-			if err != nil {
-				if ret == nil {
-					ret = err
-				}
-			} else {
-				// Set the value
-				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
-			}
-		}
-
-		/*
-			setField := reflect.ValueOf(dest).Elem().Field(i)
-			value := entityType.Field(i)
-			fldName := FieldName(value)
-			if value.Type.Kind() == reflect.Struct {
-				b.LoadStruct(append(path, fldName), setField.Interface())
-			} else {
-				err := b.GetForInterface(path, fldName, &value)
-				if err != nil {
-					fmt.Println(err)
-					return err
-				}
-				fmt.Println("value:", value)
-			}
-		*/
-
-		/*
-			if value.Type.Kind() == reflect.Struct {
-				b.LoadStruct(append(path, fldName), setField.Interface())
-			} else {
-				v, err := b.GetForType(path, fldName, value)
-				if err != nil {
-					return err
-				}
-				setField.Set(reflect.ValueOf(v))
-			}
-		*/
-	}
-	return ret
-}
-
-func (b *DB) Save(path []string, src any) error {
-	t := reflect.TypeOf(src)
-	if t.Kind() == reflect.Pointer {
-		// Save the actual struct
-		elem := reflect.ValueOf(src).Elem()
-		return b.Save(path, elem.Interface())
-	}
-
-	if t.Kind() == reflect.Struct {
-		fields := reflect.VisibleFields(t)
-		r := reflect.ValueOf(src)
-		for _, fld := range fields {
-			f := r.FieldByName(fld.Name)
-			if (f.Kind() == reflect.Struct || f.Kind() == reflect.Pointer) && f != src {
-				if f.CanInterface() {
-					err := b.Save(append(path, FieldName(fld)), f.Interface())
-					if err != nil {
-						return err
-					}
-				} else {
-					err := b.Save(append(path, FieldName(fld)), reflect.Indirect(f))
-					if err != nil {
-						return err
-					}
-				}
-			} else {
-				if err := b.Set(path, FieldName(fld), f); err != nil {
-					return err
-				}
-			}
-		}
-	} else {
-		return b.Set(path[:len(path)-1], path[len(path)-1], src)
-	}
-	return nil
-}
-
-func FieldName(fld reflect.StructField) string {
-	nm := fld.Name
-	tag := fld.Tag.Get("boltease")
-	if tag != "" {
-		nm = tag
-	}
-	return nm
-}
-func FieldIgnored(fld reflect.StructField) bool {
-	return fld.Tag.Get("boltease") == "-"
-}
-
-func ReflectValueToInterface(val reflect.Value) interface{} {
-	switch val.Kind() {
-	case reflect.Pointer:
-		return ReflectValueToInterface(reflect.Indirect(val))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return val.Int()
-	case reflect.Bool:
-		return val.Bool()
-	case reflect.String:
-		return val.String()
-	default:
-		return val.Bytes()
-	}
-}

boltease.go

@@ -1,10 +1,8 @@
 package boltease
 
 import (
-	"encoding/binary"
 	"fmt"
 	"os"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -101,160 +99,10 @@ func (b *DB) MkBucketPath(path []string) error {
 	return err
 }
 
-func (b *DB) Set(path []string, key string, val interface{}) error {
-	switch v := val.(type) {
-	case reflect.Value:
-		return b.Set(path, key, ReflectValueToInterface(v))
-	case string:
-		return b.SetString(path, key, v)
-	case int:
-		return b.SetInt(path, key, v)
-	case int8:
-		return b.SetInt(path, key, int(v))
-	case int16:
-		return b.SetInt(path, key, int(v))
-	case int32:
-		return b.SetInt(path, key, int(v))
-	case int64:
-		return b.SetInt(path, key, int(v))
-	case bool:
-		return b.SetBool(path, key, v)
-	case []byte:
-		return b.SetBytes(path, key, v)
-	default:
-		return fmt.Errorf("Unknown Data Type: %v", v)
-	}
-}
-func (b *DB) GetForInterface(path []string, key string, val interface{}) error {
-	var err error
-	switch v := val.(type) {
-	case *string:
-		*v, err = b.GetString(path, key)
-	case *int:
-		*v, err = b.GetInt(path, key)
-	case *int8:
-		var wrk int
-		wrk, err = b.GetInt(path, key)
-		*v = int8(wrk)
-	case *int16:
-		var wrk int
-		wrk, err = b.GetInt(path, key)
-		*v = int16(wrk)
-	case *int32:
-		var wrk int
-		wrk, err = b.GetInt(path, key)
-		*v = int32(wrk)
-	case *int64:
-		var wrk int
-		wrk, err = b.GetInt(path, key)
-		*v = int64(wrk)
-	case *bool:
-		*v, err = b.GetBool(path, key)
-	case *[]byte:
-		*v, err = b.GetBytes(path, key)
-	default:
-		return fmt.Errorf("Unknown Data Type: %v", v)
-	}
-	return err
-}
-func (b *DB) LoadInto(path []string, key string, into interface{}) error {
-	var err error
-	switch v := into.(type) {
-	case string:
-		i := new(string)
-		*i, err = b.GetString(path, key)
-		fmt.Printf("Loading String: %v\n", i)
-		into = i
-	case int, int8, int16, int32, int64:
-		i := new(int)
-		*i, err = b.GetInt(path, key)
-		fmt.Printf("Loading Int: %v\n", i)
-		into = i
-	case bool:
-		i := new(bool)
-		*i, err = b.GetBool(path, key)
-		fmt.Printf("Loading Bool: %v\n", i)
-		into = i
-	case []byte:
-		i := new([]byte)
-		*i, err = b.GetBytes(path, key)
-		fmt.Printf("Loading []byte: %v\n", i)
-		into = i
-	default:
-		return fmt.Errorf("Unknown Data Type: %v", v)
-	}
-	return err
-}
-
-func (b *DB) GetBytes(path []string, key string) ([]byte, error) {
-	var err error
-	var ret []byte
-	if !b.dbIsOpen {
-		if err = b.OpenDB(); err != nil {
-			return nil, err
-		}
-		defer b.CloseDB()
-	}
-	err = b.boltDB.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(path[0]))
-		if bkt == nil {
-			return fmt.Errorf("Couldn't find bucket " + path[0])
-		}
-		for idx := 1; idx < len(path); idx++ {
-			bkt = bkt.Bucket([]byte(path[idx]))
-			if bkt == nil {
-				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], "/"))
-			}
-		}
-		// newBkt should have the last bucket in the path
-		val := bkt.Get([]byte(key))
-		if val == nil {
-			return fmt.Errorf("Couldn't find value")
-		}
-		ret = make([]byte, len(val))
-		copy(ret, val)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func (b *DB) SetBytes(path []string, key string, val []byte) error {
-	var err error
-	if !b.dbIsOpen {
-		if err = b.OpenDB(); err != nil {
-			return err
-		}
-		defer b.CloseDB()
-	}
-
-	err = b.MkBucketPath(path)
-	if err != nil {
-		return err
-	}
-	err = b.boltDB.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(path[0]))
-		if bkt == nil {
-			return fmt.Errorf("Couldn't find bucket " + path[0])
-		}
-		for idx := 1; idx < len(path); idx++ {
-			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
-			if err != nil {
-				return err
-			}
-		}
-		// bkt should have the last bucket in the path
-		return bkt.Put([]byte(key), val)
-	})
-	return err
-}
-
-// GetString returns the value at path
+// GetValue returns the value at path
 // path is a slice of strings
 // key is the key to get
-func (b *DB) GetString(path []string, key string) (string, error) {
+func (b *DB) GetValue(path []string, key string) (string, error) {
 	var err error
 	var ret string
 	if !b.dbIsOpen {
@@ -271,7 +119,7 @@ func (b *DB) GetString(path []string, key string) (string, error) {
 		for idx := 1; idx < len(path); idx++ {
 			bkt = bkt.Bucket([]byte(path[idx]))
 			if bkt == nil {
-				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], "/"))
+				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx], "/"))
 			}
 		}
 		// newBkt should have the last bucket in the path
@@ -281,9 +129,9 @@ func (b *DB) GetString(path []string, key string) (string, error) {
 	return ret, err
 }
 
-// SetString sets the value of key at path to val
+// SetValue sets the value of key at path to val
 // path is a slice of tokens
-func (b *DB) SetString(path []string, key, val string) error {
+func (b *DB) SetValue(path []string, key, val string) error {
 	var err error
 	if !b.dbIsOpen {
 		if err = b.OpenDB(); err != nil {
@@ -317,7 +165,7 @@ func (b *DB) SetString(path []string, key, val string) error {
 // If the value cannot be parsed as an int, error
 func (b *DB) GetInt(path []string, key string) (int, error) {
 	var ret int
-	r, err := b.GetString(path, key)
+	r, err := b.GetValue(path, key)
 	if err == nil {
 		ret, err = strconv.Atoi(r)
 	}
@@ -326,7 +174,7 @@ func (b *DB) GetInt(path []string, key string) (int, error) {
 
 // SetInt Sets an integer value
 func (b *DB) SetInt(path []string, key string, val int) error {
-	return b.SetString(path, key, strconv.Itoa(val))
+	return b.SetValue(path, key, strconv.Itoa(val))
 }
 
 // GetBool returns the value at 'path'
@@ -334,7 +182,7 @@ func (b *DB) SetInt(path []string, key string, val int) error {
 // We check 'true/false' and '1/0', else error
 func (b *DB) GetBool(path []string, key string) (bool, error) {
 	var ret bool
-	r, err := b.GetString(path, key)
+	r, err := b.GetValue(path, key)
 	if err == nil {
 		if r == "true" || r == "1" {
 			ret = true
@@ -348,15 +196,15 @@ func (b *DB) GetBool(path []string, key string) (bool, error) {
 // SetBool Sets a boolean value
 func (b *DB) SetBool(path []string, key string, val bool) error {
 	if val {
-		return b.SetString(path, key, "true")
+		return b.SetValue(path, key, "true")
 	}
-	return b.SetString(path, key, "false")
+	return b.SetValue(path, key, "false")
 }
 
 // GetTimestamp returns the value at 'path'
 // If the value cannot be parsed as a RFC3339, error
 func (b *DB) GetTimestamp(path []string, key string) (time.Time, error) {
-	r, err := b.GetString(path, key)
+	r, err := b.GetValue(path, key)
 	if err == nil {
 		return time.Parse(time.RFC3339, r)
 	}
@@ -365,7 +213,7 @@ func (b *DB) GetTimestamp(path []string, key string) (time.Time, error) {
 
 // SetTimestamp saves a timestamp into the db
 func (b *DB) SetTimestamp(path []string, key string, val time.Time) error {
-	return b.SetString(path, key, val.Format(time.RFC3339))
+	return b.SetValue(path, key, val.Format(time.RFC3339))
 }
 
 // GetBucketList returns a list of all sub-buckets at path
@@ -389,7 +237,7 @@ func (b *DB) GetBucketList(path []string) ([]string, error) {
 			for idx := 1; idx < len(path); idx++ {
 				bkt = bkt.Bucket([]byte(path[idx]))
 				if bkt == nil {
-					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], " / "))
+					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx], " / "))
 				}
 			}
 		}
@@ -512,8 +360,8 @@ func (b *DB) DeleteBucket(path []string, key string) error {
 	return err
 }
 
-// GetStringList returns a string slice of all values in the bucket at path
-func (b *DB) GetStringList(path []string) ([]string, error) {
+// GetValueList returns a string slice of all values in the bucket at path
+func (b *DB) GetValueList(path []string) ([]string, error) {
 	var err error
 	var ret []string
 	if !b.dbIsOpen {
@@ -523,85 +371,6 @@ func (b *DB) GetStringList(path []string) ([]string, error) {
 		defer b.CloseDB()
 	}
 
-	err = b.boltDB.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(path[0]))
-		if bkt == nil {
-			return fmt.Errorf("Couldn't find bucket " + path[0])
-		}
-		var berr error
-		if len(path) > 1 {
-			for idx := 1; idx < len(path); idx++ {
-				bkt = bkt.Bucket([]byte(path[idx]))
-				if bkt == nil {
-					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], " / "))
-				}
-			}
-		}
-
-		// bkt should have the last bucket in the path
-		berr = bkt.ForEach(func(k, v []byte) error {
-			if v != nil {
-				// Must be a key
-				ret = append(ret, string(v))
-			}
-			return nil
-		})
-		return berr
-	})
-	return ret, err
-}
-
-// SetStringList puts a string slice into the bucket at path
-func (b *DB) SetStringList(path, values []string) error {
-	var err error
-	if !b.dbIsOpen {
-		if err = b.OpenDB(); err != nil {
-			return err
-		}
-		defer b.CloseDB()
-	}
-
-	err = b.MkBucketPath(path)
-	if err != nil {
-		return err
-	}
-	err = b.boltDB.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(path[0]))
-		if bkt == nil {
-			return fmt.Errorf("Couldn't find bucket " + path[0])
-		}
-		for idx := 1; idx < len(path); idx++ {
-			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
-			if err != nil {
-				return err
-			}
-		}
-		// bkt should have the last bucket in the path
-		for _, v := range values {
-			id, _ := bkt.NextSequence()
-			bId := make([]byte, 8)
-			binary.BigEndian.PutUint64(bId, id)
-			err = bkt.Put(bId, []byte(v))
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	return err
-}
-
-// GetKeyValueMap returns a map of all key/value pairs in the bucket at path
-func (b *DB) GetKeyValueMap(path []string) (map[string][]byte, error) {
-	var err error
-	ret := make(map[string][]byte)
-	if !b.dbIsOpen {
-		if err = b.OpenDB(); err != nil {
-			return ret, err
-		}
-		defer b.CloseDB()
-	}
-
 	err = b.boltDB.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket([]byte(path[0]))
 		if bkt == nil {
@@ -621,7 +390,7 @@ func (b *DB) GetKeyValueMap(path []string) (map[string][]byte, error) {
 		berr = bkt.ForEach(func(k, v []byte) error {
 			if v != nil {
 				// Must be a key
-				ret[string(k)] = v
+				ret = append(ret, string(v))
 			}
 			return nil
 		})
@@ -629,62 +398,3 @@ func (b *DB) GetKeyValueMap(path []string) (map[string][]byte, error) {
 	})
 	return ret, err
 }
-
-// GetKeyValueStringMap returns all key/value pairs at path as a map
-func (b *DB) GetKeyValueStringMap(path []string) (map[string]string, error) {
-	ret := make(map[string]string)
-	btMap, err := b.GetKeyValueMap(path)
-	if err != nil {
-		return ret, err
-	}
-	for k, v := range btMap {
-		ret[k] = string(v)
-	}
-	return ret, err
-}
-
-// SetKeyValueMap puts all key/value pairs into the bucket at path
-func (b *DB) SetKeyValueMap(path []string, kvMap map[string][]byte) error {
-	var err error
-	if !b.dbIsOpen {
-		if err = b.OpenDB(); err != nil {
-			return err
-		}
-		defer b.CloseDB()
-	}
-
-	err = b.MkBucketPath(path)
-	if err != nil {
-		return err
-	}
-	err = b.boltDB.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(path[0]))
-		if bkt == nil {
-			return fmt.Errorf("Couldn't find bucket " + path[0])
-		}
-		for idx := 1; idx < len(path); idx++ {
-			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
-			if err != nil {
-				return err
-			}
-		}
-		// bkt should have the last bucket in the path
-		for k, v := range kvMap {
-			err = bkt.Put([]byte(k), v)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	return err
-}
-
-// SetKeyValueStringMap takes a map[string]string and puts all key/value pairs into the bucket at path
-func (b *DB) SetKeyValueStringMap(path []string, kvMap map[string]string) error {
-	chain := make(map[string][]byte)
-	for k, v := range kvMap {
-		chain[k] = []byte(v)
-	}
-	return b.SetKeyValueMap(path, chain)
-}

example/.gitignore

@@ -1,2 +0,0 @@
-example
-example.db

example/main.go

@@ -1,136 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"git.bullercodeworks.com/brian/boltease"
-)
-
-func main() {
-	//example1()
-	//fmt.Println()
-	example2()
-}
-
-func example1() {
-	fmt.Println("# Example 1")
-	db, err := boltease.Create("example.db", 0600, nil)
-	if err != nil {
-		fmt.Printf("Error Opening File: %s\n", err.Error())
-		os.Exit(1)
-	}
-
-	fmt.Println("## Saving Struct")
-	err = db.Save(
-		[]string{"examples", "example1"},
-		ExampleType{
-			Name: "Example 1",
-			Age:  5,
-		})
-	if err != nil {
-		fmt.Printf("Error saving struct: %s\n", err.Error())
-		os.Exit(1)
-	}
-
-	fmt.Println("## Example 1-1: Simple")
-	var v string
-	err = db.GetForInterface([]string{"examples", "example1"}, "name", &v)
-	if err != nil {
-		fmt.Println("Error:", err.Error())
-	}
-	fmt.Println("Name:", v)
-	var age int
-	err = db.GetForInterface([]string{"examples", "example1"}, "age", &age)
-	if err != nil {
-		fmt.Println("Error:", err.Error())
-	}
-	fmt.Println("Age:", age)
-	fmt.Println("")
-
-	fmt.Println("## Example 1-2: LoadStruct, simple")
-	var name string
-	err = db.Load(
-		[]string{"examples", "example1", "name"},
-		&name,
-	)
-	fmt.Println("Name:", name)
-	if err != nil {
-		fmt.Println("Err:", err)
-	}
-	fmt.Println("")
-
-	fmt.Println("## Example 1-3: Struct")
-	fmt.Println("Loading into Struct")
-	newStruct := ExampleType{}
-	err = db.Load(
-		[]string{"examples", "example1"},
-		&newStruct,
-	)
-	fmt.Println(newStruct)
-}
-
-func example2() {
-	fmt.Println("# Example 2")
-	db, err := boltease.Create("example.db", 0600, nil)
-	if err != nil {
-		fmt.Printf("Error Opening File: %s\n", err.Error())
-		os.Exit(1)
-	}
-	fmt.Println("## Saving Struct")
-	num := 12345
-	err = db.Save(
-		[]string{"examples", "example2"},
-		&ExampleType2{
-			Name: "Example 2",
-			Age:  20,
-			SubTypePtr: &ExampleSubType{
-				SubName: "Example SubType Pointer",
-			},
-			SubType: ExampleSubType{
-				SubName: "Example SubType",
-			},
-			Number: &num,
-		})
-	if err != nil {
-		fmt.Printf("Error saving struct: %s\n", err.Error())
-		os.Exit(1)
-	}
-
-	newStruct := ExampleType2{}
-	err = db.Load([]string{"examples", "example2"}, &newStruct)
-	fmt.Println(newStruct)
-}
-
-type ExampleType struct {
-	Name string `boltease:"name"`
-	Age  int    `boltease:"age"`
-}
-
-func (e ExampleType) String() string {
-	r, _ := json.Marshal(e)
-	return string(r)
-}
-
-type ExampleType2 struct {
-	Name       string          `boltease:"name"`
-	Age        int             `boltease:"age"`
-	SubTypePtr *ExampleSubType `boltease:"subtypeptr"`
-	SubType    ExampleSubType  `boltease:"subtype"`
-	Number     *int            `boltease:"number"`
-}
-
-func (e ExampleType2) String() string {
-	r, _ := json.Marshal(e)
-	return string(r)
-}
-
-type ExampleSubType struct {
-	SubName string `boltease:"subname"`
-}
-
-func (e ExampleSubType) String() string {
-	r, _ := json.Marshal(e)
-	return string(r)
-}

go.mod

@@ -1,8 +1,7 @@
 module git.bullercodeworks.com/brian/boltease
 
-go 1.16
+go 1.20
 
-require (
-	github.com/boltdb/bolt v1.3.1
-	golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf // indirect
-)
+require github.com/boltdb/bolt v1.3.1
+
+require golang.org/x/sys v0.5.0 // indirect

go.sum

@@ -1,4 +1,4 @@
 github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
 github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
-golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf h1:2ucpDCmfkl8Bd/FsLtiD653Wf96cW37s+iGx93zsu4k=
-golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=