Adding support for data types

bolt_model.go

@@ -35,6 +35,7 @@ type BoltPair struct {
 	parent   *BoltBucket
 	key      string
 	val      string
+	dataType *Datatype
 }
 
 func (bd *BoltDB) getGenericFromPath(path []string) (*BoltBucket, *BoltPair, error) {

datatype.go

@@ -0,0 +1,9 @@
+package main
+
+// A Datatype interface knows how to convert a byte slice into a
+// specific data type.
+type Datatype interface {
+	Name() string                      // Type Name, for UI display
+	ToString([]byte) (string, error)   // ToString takes a []byte from the DB and returns the string to display
+	FromString(string) ([]byte, error) // FromString takes a string and returns the []byte for the DB
+}

datatype_int.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"encoding/binary"
+	"errors"
+	"strconv"
+)
+
+// Datatype_Uint64 manages the uint64 data type
+// All conversions just use the binary package
+type Datatype_Uint64 struct{}
+
+func (t *Datatype_Uint64) Name() string {
+	return "uint64"
+}
+
+func (t *Datatype_Uint64) ToString(data []byte) (string, error) {
+	ret, bt := binary.Uvarint(data)
+	if bt == 0 {
+		return "", errors.New("Byte Buffer too small")
+	} else if bt < 0 {
+		return "", errors.New("Value larger than 64 bits")
+	}
+	return strconv.FormatUint(ret, 10), nil
+}
+
+func (t *Datatype_Uint64) FromString(val string) ([]byte, error) {
+	var err error
+	var u uint64
+	buf := make([]byte, binary.MaxVarintLen64)
+	u, err = strconv.ParseUint(val, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	binary.PutUvarint(buf, u)
+	return buf, nil
+}

datatype_string.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"errors"
+	"unicode/utf8"
+)
+
+// Datatype_String is basically the default type for
+// boltbrowser (and the boltease library)
+type Datatype_String struct{}
+
+func (t *Datatype_String) Name() string {
+	return "string"
+}
+
+func (t *Datatype_String) ToString(data []byte) (string, error) {
+	if utf8.Valid(data) {
+		ok := true
+		for _, r := range string(data) {
+			if r < 0x20 {
+				ok = false
+				break
+			} else if r >= 0x7f && r <= 0x9f {
+				ok = false
+				break
+			}
+		}
+		if ok {
+			return string(data), nil
+		}
+	}
+	return "", errors.New("Invalid String Data")
+}
+
+func (t *Datatype_String) FromString(val string) ([]byte, error) {
+	return []byte(val), nil
+}

main.go

@@ -18,6 +18,8 @@ var databaseFiles []string
 var db *bolt.DB
 var memBolt *BoltDB
 
+var datatypes map[string]Datatype
+
 var currentFilename string
 
 const DefaultDBOpenTimeout = time.Second
@@ -95,6 +97,7 @@ func main() {
 	var err error
 
 	parseArgs()
+	initDataTypes()
 
 	err = termbox.Init()
 	if err != nil {
@@ -134,3 +137,13 @@ func main() {
 		defer db.Close()
 	}
 }
+
+func initDataTypes() {
+	datatypes = make(map[string]Datatype)
+	for _, t := range []Datatype{
+		&Datatype_String{},
+		&Datatype_Uint64{},
+	} {
+		datatypes[t.Name()] = t
+	}
+}

screen_browser.go

@@ -204,6 +204,10 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
 	} else if event.Ch == 'X' {
 		// Export Key/Value (or Bucket) as JSON
 		screen.startExportJSON()
+
+	} else if event.Ch == 't' {
+		// TODO: change the type of the pair value being viewed
+
 	}
 	return BrowserScreenIndex
 }