func (c *MemoryCollector) GetNumOfCreatedBlocks(layer types.LayerID) int {
	c.lck.RLock()
	defer c.lck.RUnlock()
	created := 0
	for _, atx := range c.doneCreatingBlockEvent[layer.Uint32()] {
		if atx.Eligible {
			created++
		}
	}
	return created
}
GetNumOfCreatedBlocks returns number of blocks created events received by this miner.
package collector
import (
	"sync"
	"github.com/spacemeshos/go-spacemesh/common/types"
	"github.com/spacemeshos/go-spacemesh/events"
)
type MemoryCollector struct {
	events                 map[events.ChannelID][]Event
	doneCreatingBlockEvent map[uint32][]*events.DoneCreatingBlock
	doneCreatingAtxEvent   map[uint32][]*events.AtxCreated
	createdAtxs            map[uint32][]string
	gotBlockEvent          map[uint32][]*events.NewBlock
	gotAtxEvent            map[uint32][]*events.NewAtx
	Atxs                   map[string]uint32
	tortoiseBeacons        map[types.EpochID][]string
	lck sync.RWMutex
}
func NewMemoryCollector() *MemoryCollector {
	return &MemoryCollector{
		events:                 make(map[events.ChannelID][]Event),
		doneCreatingBlockEvent: make(map[uint32][]*events.DoneCreatingBlock),
		doneCreatingAtxEvent:   make(map[uint32][]*events.AtxCreated),
		gotBlockEvent:          make(map[uint32][]*events.NewBlock),
		gotAtxEvent:            make(map[uint32][]*events.NewAtx),
		Atxs:                   make(map[string]uint32),
		createdAtxs:            make(map[uint32][]string),
		tortoiseBeacons:        make(map[types.EpochID][]string),
	}
}
type Event interface {
	GetChannel() events.ChannelID
}
func (c *MemoryCollector) StoreBlock(event *events.NewBlock) error {
	c.lck.Lock()
	c.events[event.GetChannel()] = append(c.events[event.GetChannel()], event)
	c.gotBlockEvent[event.Layer] = append(c.gotBlockEvent[event.Layer], event)
	c.lck.Unlock()
	return nil
}
func (c *MemoryCollector) StoreBlockValid(event *events.ValidBlock) error {
	return nil
}
func (c *MemoryCollector) StoreTx(event *events.NewTx) error {
	return nil
}
func (c *MemoryCollector) StoreTxValid(event *events.ValidTx) error {
	return nil
}
func (c *MemoryCollector) StoreAtx(event *events.NewAtx) error {
	c.lck.Lock()
	c.events[event.GetChannel()] = append(c.events[event.GetChannel()], event)
	c.gotAtxEvent[event.EpochID] = append(c.gotAtxEvent[event.EpochID], event)
	c.Atxs[event.ID]++
	c.lck.Unlock()
	return nil
}
func (c *MemoryCollector) StoreAtxValid(event *events.ValidAtx) error {
	return nil
}
func (c *MemoryCollector) StoreReward(event *events.RewardReceived) error {
	return nil
}
func (c *MemoryCollector) StoreBlockCreated(event *events.DoneCreatingBlock) error {
	c.lck.Lock()
	c.events[event.GetChannel()] = append(c.events[event.GetChannel()], event)
	c.doneCreatingBlockEvent[event.Layer] = append(c.doneCreatingBlockEvent[event.Layer], event)
	c.lck.Unlock()
	return nil
}
func (c *MemoryCollector) StoreAtxCreated(event *events.AtxCreated) error {
	c.lck.Lock()
	c.events[event.GetChannel()] = append(c.events[event.GetChannel()], event)
	c.doneCreatingAtxEvent[event.Epoch] = append(c.doneCreatingAtxEvent[event.Epoch], event)
	if event.Created {
		c.createdAtxs[event.Epoch] = append(c.createdAtxs[event.Epoch], event.ID)
	}
	c.lck.Unlock()
	return nil
}
func (c *MemoryCollector) StoreTortoiseBeaconCalculated(event *events.TortoiseBeaconCalculated) error {
	c.lck.Lock()
	c.events[event.GetChannel()] = append(c.events[event.GetChannel()], event)
	c.tortoiseBeacons[event.Epoch] = append(c.tortoiseBeacons[event.Epoch], event.Beacon)
	c.lck.Unlock()
	return nil
}
func (c *MemoryCollector) GetAtxCreationDone(epoch types.EpochID) int {
	c.lck.RLock()
	defer c.lck.RUnlock()
	return len(c.doneCreatingAtxEvent[uint32(epoch)])
}
func (c *MemoryCollector) GetCreatedAtx(epoch types.EpochID) []string {
	c.lck.RLock()
	defer c.lck.RUnlock()
	return c.createdAtxs[uint32(epoch)]
}
func (c *MemoryCollector) GetNumOfCreatedATXs(layer types.LayerID) int {
	c.lck.RLock()
	defer c.lck.RUnlock()
	return len(c.createdAtxs[layer.Uint32()])
}
func (c *MemoryCollector) GetReceivedATXsNum(layer types.LayerID) int {
	c.lck.RLock()
	defer c.lck.RUnlock()
	return len(c.gotAtxEvent[layer.Uint32()])
}
func (c *MemoryCollector) GetBlockCreationDone(layer types.LayerID) int {
	c.lck.RLock()
	defer c.lck.RUnlock()
	return len(c.doneCreatingBlockEvent[layer.Uint32()])
}