cache

// We start with a simple example of storing uint64 serialized to binary

// First, we create a fake file (we need something that implements io.ReadWriter)
timestampsCacheFile := new(bytes.Buffer)
// Now we point our cache item to use this "file". This is temporary, it will be
// handled by some higher abstraction (CacheLayout perhaps?)
timestampsCacheItem := NewItem(timestampsCacheFile)
// We encode (serialize to binary) the value. The cache header is written automatically
// by Encode()
if err := timestampsCacheItem.Encode(uint64(1688667358)); err != nil {
	panic(err)
}

// Let's read the value
var timestamp uint64
// Decode checks cache header automatically
if err := timestampsCacheItem.Decode(&timestamp); err != nil {
	panic(err)
}
fmt.Println(timestamp)

// Now we will write a structure which implements Cache(un)Marshaler
block := &ExampleBlock{
	BlockNumber: 17636511,
	Date:        "2023-07-06",
	Name:        "Nice Block",
	Timestamp:   1688667358,
}

// Again, we create a fake file and cache item linked to it. And again, it'll be
// more automated later
blocksCacheFile := new(bytes.Buffer)
blocksCacheItem := NewItem(blocksCacheFile)
// We call Encode() to serialize to  Cache header is written by default
if err := blocksCacheItem.Encode(block); err != nil {
	panic(err)
}

// Now we can read the struct back
decodedBlock := &ExampleBlock{}
if err := blocksCacheItem.Decode(decodedBlock); err != nil {
	panic(err)
}
fmt.Printf("%+v\n", decodedBlock)

Output:
1688667358
&{BlockNumber:17636511 Date: Name:Nice Block Timestamp:1688667358}