Merge pull request #2 from i5heu/refactor

Big refactor of the Event type

internal/binaryCoder/binaryCoder.go

@@ -17,17 +17,58 @@ func ByteToEvent(bytes []byte) (types.Event, error) {
 	if err := proto.Unmarshal(bytes, pbEvent); err != nil {
 		return types.Event{}, fmt.Errorf("Error decoding Event: %v", err)
 	}
-	item := convertFromProtoEvent(pbEvent)
+	item, err := convertFromProtoEvent(pbEvent)
+	if err != nil {
+		return types.Event{}, fmt.Errorf("Error converting from proto event: %v", err)
+	}
 
 	return item, nil
 }
 
 func EventToByte(event types.Event) ([]byte, error) {
-	pbEvent := convertToProtoEvent(event)
+	pbEvent, err := convertToProtoEvent(event)
+	if err != nil {
+		return nil, fmt.Errorf("Error converting to proto event: %v", err)
+	}
 	data, err := proto.Marshal(pbEvent)
 	if err != nil {
-		return data, err
+		return nil, fmt.Errorf("Error marshalling proto event: %v", err)
 	}
 
 	return data, nil
 }
+
+func convertToProtoEvent(event types.Event) (*EventProto, error) {
+	return &EventProto{
+		EventIdentifier: &EventIdentifierProto{
+			EventHash: event.EventIdentifier.EventHash[:],
+			EventType: int32(event.EventIdentifier.EventType),
+			FastMeta:  event.EventIdentifier.FastMeta.Bytes(),
+		},
+		Level:          int64(event.Level),
+		ContentHashes:  chunkMetasToBytes(event.Content),
+		MetadataHashes: chunkMetasToBytes(event.Metadata),
+		ParentEvent:    event.ParentEvent[:],
+		RootEvent:      event.RootEvent[:],
+		Temporary:      bool(event.Temporary),
+		FullTextSearch: bool(event.FullTextSearch),
+	}, nil
+}
+
+func convertFromProtoEvent(pbEvent *EventProto) (types.Event, error) {
+	event := types.Event{
+		EventIdentifier: types.EventIdentifier{
+			EventHash: bytesToHash(pbEvent.EventIdentifier.EventHash),
+			EventType: types.EventType(pbEvent.EventIdentifier.EventType),
+			FastMeta:  bytesToFastMeta(pbEvent.EventIdentifier.FastMeta),
+		},
+		Level:          types.Level(pbEvent.Level),
+		Content:        bytesToChunkMetas(pbEvent.ContentHashes),
+		Metadata:       bytesToChunkMetas(pbEvent.MetadataHashes),
+		ParentEvent:    bytesToHash(pbEvent.ParentEvent),
+		RootEvent:      bytesToHash(pbEvent.RootEvent),
+		Temporary:      types.Binary(pbEvent.Temporary),
+		FullTextSearch: types.Binary(pbEvent.FullTextSearch),
+	}
+	return event, nil
+}

internal/binaryCoder/binaryCoding.go

@@ -4,57 +4,67 @@ import (
 	"github.com/i5heu/ouroboros-db/pkg/types"
 )
 
-// Convert an Event to an EventProto
-func convertToProtoEvent(ev types.Event) *EventProto {
+func EventToProto(event types.Event) (*EventProto, error) {
 	return &EventProto{
-		Key:               ev.Key,
-		EventHash:         ev.EventHash[:],
-		Level:             ev.Level,
-		ContentHashes:     hashesToBytes(ev.ContentHashes),
-		MetadataHashes:    hashesToBytes(ev.MetadataHashes),
-		HashOfParentEvent: ev.HashOfParentEvent[:],
-		HashOfRootEvent:   ev.HashOfRootEvent[:],
-		Temporary:         ev.Temporary,
-		FullTextSearch:    ev.FullTextSearch,
-	}
+		EventIdentifier: &EventIdentifierProto{
+			EventHash: event.EventIdentifier.EventHash[:],
+			EventType: int32(event.EventIdentifier.EventType),
+			FastMeta:  event.EventIdentifier.FastMeta.Bytes(),
+		},
+		Level:          int64(event.Level),
+		ContentHashes:  chunkMetasToBytes(event.Content),
+		MetadataHashes: chunkMetasToBytes(event.Metadata),
+		ParentEvent:    event.ParentEvent[:],
+		RootEvent:      event.RootEvent[:],
+		Temporary:      bool(event.Temporary),
+		FullTextSearch: bool(event.FullTextSearch),
+	}, nil
 }
 
-// Convert an EventProto to an Event
-func convertFromProtoEvent(pbEvent *EventProto) types.Event {
-	return types.Event{
-		Key:               pbEvent.GetKey(),
-		EventHash:         bytesToHash(pbEvent.GetEventHash()),
-		Level:             pbEvent.GetLevel(),
-		ContentHashes:     bytesToHashes(pbEvent.GetContentHashes()),
-		MetadataHashes:    bytesToHashes(pbEvent.GetMetadataHashes()),
-		HashOfParentEvent: bytesToHash(pbEvent.GetHashOfParentEvent()),
-		HashOfRootEvent:   bytesToHash(pbEvent.GetHashOfRootEvent()),
-		Temporary:         pbEvent.GetTemporary(),
-		FullTextSearch:    pbEvent.GetFullTextSearch(),
+func ProtoToEvent(protoEvent *EventProto) (types.Event, error) {
+	event := types.Event{
+		EventIdentifier: types.EventIdentifier{
+			EventHash: bytesToHash(protoEvent.EventIdentifier.EventHash),
+			EventType: types.EventType(protoEvent.EventIdentifier.EventType),
+			FastMeta:  bytesToFastMeta(protoEvent.EventIdentifier.FastMeta),
+		},
+		Level:          types.Level(protoEvent.Level),
+		Content:        bytesToChunkMetas(protoEvent.ContentHashes),
+		Metadata:       bytesToChunkMetas(protoEvent.MetadataHashes),
+		ParentEvent:    bytesToHash(protoEvent.ParentEvent),
+		RootEvent:      bytesToHash(protoEvent.RootEvent),
+		Temporary:      types.Binary(protoEvent.Temporary),
+		FullTextSearch: types.Binary(protoEvent.FullTextSearch),
 	}
+	return event, nil
 }
 
-// Convert a slice of [64]byte hashes to a slice of byte slices
-func hashesToBytes(hashes [][64]byte) [][]byte {
-	result := make([][]byte, len(hashes))
-	for i, hash := range hashes {
-		result[i] = hash[:]
+func chunkMetasToBytes(metas types.ChunkMetaCollection) [][]byte {
+	var result [][]byte
+	for _, meta := range metas {
+		result = append(result, meta.Hash[:])
 	}
 	return result
 }
 
-// Convert a slice of byte slices to a slice of [64]byte hashes
-func bytesToHashes(byteSlices [][]byte) [][64]byte {
-	hashes := make([][64]byte, len(byteSlices))
-	for i, bytes := range byteSlices {
-		copy(hashes[i][:], bytes)
+func bytesToChunkMetas(data [][]byte) types.ChunkMetaCollection {
+	var result types.ChunkMetaCollection
+	for _, d := range data {
+		var hash types.Hash
+		copy(hash[:], d)
+		result = append(result, types.ChunkMeta{Hash: hash})
 	}
-	return hashes
+	return result
 }
 
-// Convert a byte slice to a [64]byte hash
-func bytesToHash(b []byte) [64]byte {
-	var hash [64]byte
-	copy(hash[:], b)
+func bytesToHash(data []byte) types.Hash {
+	var hash types.Hash
+	copy(hash[:], data)
 	return hash
 }
+
+func bytesToFastMeta(data []byte) types.FastMeta {
+	var fastMeta types.FastMeta
+	fastMeta.FromBytes(data)
+	return fastMeta
+}