go fmt

db/level_db.go

@@ -1,54 +1,60 @@
 package db
 
 import (
-    "fmt"
-    "github.com/syndtr/goleveldb/leveldb"
-    "path"
+	"fmt"
+	"github.com/syndtr/goleveldb/leveldb"
+	"path"
 )
 
 type LevelDB struct {
-    db *leveldb.DB
+	db *leveldb.DB
 }
 
 func NewLevelDB(name string) (*LevelDB, error) {
-    dbPath := path.Join(name)
-    db, err := leveldb.OpenFile(dbPath, nil)
-    if err != nil {
-        return nil, err
-    }
-    database := &LevelDB{db: db}
-    return database, nil
+	dbPath := path.Join(name)
+	db, err := leveldb.OpenFile(dbPath, nil)
+	if err != nil {
+		return nil, err
+	}
+	database := &LevelDB{db: db}
+	return database, nil
 }
 
 func (db *LevelDB) Put(key []byte, value []byte) {
-    err := db.db.Put(key, value, nil)
-    if err != nil { panic(err) }
+	err := db.db.Put(key, value, nil)
+	if err != nil {
+		panic(err)
+	}
 }
 
-func (db *LevelDB) Get(key []byte) ([]byte) {
-    res, err := db.db.Get(key, nil)
-    if err != nil { panic(err) }
-    return res
+func (db *LevelDB) Get(key []byte) []byte {
+	res, err := db.db.Get(key, nil)
+	if err != nil {
+		panic(err)
+	}
+	return res
 }
 
 func (db *LevelDB) Delete(key []byte) {
-    err := db.db.Delete(key, nil)
-    if err != nil { panic(err) }
+	err := db.db.Delete(key, nil)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func (db *LevelDB) Db() *leveldb.DB {
-    return db.db
+	return db.db
 }
 
 func (db *LevelDB) Close() {
-    db.db.Close()
+	db.db.Close()
 }
 
 func (db *LevelDB) Print() {
-    iter := db.db.NewIterator(nil, nil)
-    for iter.Next() {
-        key := iter.Key()
-        value := iter.Value()
-        fmt.Printf("[%x]:\t[%x]", key, value)
-    }
+	iter := db.db.NewIterator(nil, nil)
+	for iter.Next() {
+		key := iter.Key()
+		value := iter.Value()
+		fmt.Printf("[%x]:\t[%x]", key, value)
+	}
 }

db/mem_db.go

@@ -1,32 +1,32 @@
 package db
 
 import (
-    "fmt"
+	"fmt"
 )
 
 type MemDB struct {
-    db map[string][]byte
+	db map[string][]byte
 }
 
-func NewMemDB() (*MemDB) {
-    database := &MemDB{db:make(map[string][]byte)}
-    return database
+func NewMemDB() *MemDB {
+	database := &MemDB{db: make(map[string][]byte)}
+	return database
 }
 
 func (db *MemDB) Put(key []byte, value []byte) {
-    db.db[string(key)] = value
+	db.db[string(key)] = value
 }
 
-func (db *MemDB) Get(key []byte) ([]byte) {
-    return db.db[string(key)]
+func (db *MemDB) Get(key []byte) []byte {
+	return db.db[string(key)]
 }
 
 func (db *MemDB) Delete(key []byte) {
-    delete(db.db, string(key))
+	delete(db.db, string(key))
 }
 
 func (db *MemDB) Print() {
-    for key, value := range db.db {
-        fmt.Printf("[%x]:\t[%x]", []byte(key), value)
-    }
+	for key, value := range db.db {
+		fmt.Printf("[%x]:\t[%x]", []byte(key), value)
+	}
 }