// Make this stuff easier to read.
func Unmarshall(thing interfaces.BinaryMarshallable, err error, data []byte) ([]byte, error) {
if err != nil {
return nil, err
}
newdata, err := thing.UnmarshalBinaryData(data)
return newdata, err
}
func (db *BoltDB) Get(bucket []byte, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.Sem.RLock()
defer db.Sem.RUnlock()
var v []byte
db.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(bucket)
if b == nil {
return nil
}
v = b.Get(key)
if v == nil {
return nil
}
return nil
})
if v == nil { // If the value is undefined, return nil
return nil, nil
}
_, err := destination.UnmarshalBinaryData(v)
if err != nil {
return nil, err
}
return destination, nil
}
func (db *MapDB) Get(bucket, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.createCache(bucket)
db.Sem.RLock()
defer db.Sem.RUnlock()
if db.Cache == nil {
db.Cache = map[string]map[string][]byte{}
}
_, ok := db.Cache[string(bucket)]
if ok == false {
db.Cache[string(bucket)] = map[string][]byte{}
}
v, ok := db.Cache[string(bucket)][string(key)]
if ok == false {
return nil, nil
}
if v == nil {
return nil, nil
}
_, err := destination.UnmarshalBinaryData(v)
if err != nil {
return nil, err
}
return destination, nil
}
func TestCommitMarshalUnmarshal(t *testing.T) {
blocks := testHelper.CreateFullTestBlockSet()
for _, block := range blocks {
for _, tx := range block.ECBlock.GetEntries() {
h1, err := tx.MarshalBinary()
if err != nil {
t.Errorf("Error marshalling - %v", err)
}
var h2 []byte
var e interfaces.BinaryMarshallable
switch tx.ECID() {
case ECIDChainCommit:
e = new(CommitChain)
break
case ECIDEntryCommit:
e = new(CommitEntry)
break
case ECIDBalanceIncrease:
e = new(IncreaseBalance)
break
case ECIDMinuteNumber:
e = new(MinuteNumber)
break
case ECIDServerIndexNumber:
e = new(ServerIndexNumber)
break
default:
t.Error("Wrong ECID")
break
}
h2, err = e.UnmarshalBinaryData(h1)
if err != nil {
t.Logf("Tried to unmarshal %x", h1)
t.Errorf("Error unmarshalling - %v", err)
continue
}
if len(h2) > 0 {
t.Errorf("Leftovers from unmarshalling - %x", h2)
}
h2, err = e.MarshalBinary()
if err != nil {
t.Errorf("Error marshalling2 - %v", err)
continue
}
if primitives.AreBytesEqual(h1, h2) == false {
t.Error("ECEntries are not identical - %x vs %x", h1, h2)
}
}
}
}
func (db *LevelDB) Get(bucket []byte, key []byte, destination interfaces.BinaryMarshallable) (interfaces.BinaryMarshallable, error) {
db.dbLock.Lock()
defer db.dbLock.Unlock()
ldbKey := append(bucket, key...)
data, err := db.lDB.Get(ldbKey, db.ro)
if err != nil {
if strings.Contains(err.Error(), "not found") {
return nil, nil
}
return nil, err
}
_, err = destination.UnmarshalBinaryData(data)
if err != nil {
return nil, err
}
return destination, nil
}
