Hibiki/utilities/specializedstore/memory.go

package specializedstore

import "git.gammaspectra.live/S.O.N.G/Hibiki/strategy/panako"

type MemoryStore struct {
	prints map[uint64][]panako.StoreRecord
}

func NewMemoryStore() *MemoryStore {
	return &MemoryStore{
		prints: make(map[uint64][]panako.StoreRecord),
	}
}

func (s *MemoryStore) GetPrints() map[uint64][]panako.StoreRecord {
	return s.prints
}

func (s *MemoryStore) GetPanakoMatch(record panako.StoreRecord, lookupRange int) []panako.MatchedRecord {
	keyStart := record.Hash - uint64(lookupRange)
	keyStop := record.Hash + uint64(lookupRange)

	var matches []panako.MatchedRecord

	for key := keyStart; key <= keyStop; key++ {
		v, ok := s.prints[key]
		if ok {
			for _, r := range v {
				matches = append(matches, panako.MatchedRecord{
					Query: record,
					Match: r,
				})
			}
		}
	}

	return matches
}
func (s *MemoryStore) GetPanakoMatches(records []panako.StoreRecord, lookupRange int) []panako.MatchedRecord {
	var matches []panako.MatchedRecord
	for _, record := range records {
		matches = append(matches, s.GetPanakoMatch(record, lookupRange)...)
	}

	return matches
}

func (s *MemoryStore) GetPanakoRecords(resourceId panako.ResourceId) []panako.StoreRecord {
	return nil
}

func (s *MemoryStore) recordExists(record panako.StoreRecord) bool {
	v, ok := s.prints[record.Hash]
	if ok {
		for _, r := range v {
			if record.ResourceId == r.ResourceId && record.Time == r.Time && record.Frequency == r.Frequency {
				return true
			}
		}
	}

	return false
}
func (s *MemoryStore) StorePanakoPrint(record panako.StoreRecord) {
	if !s.recordExists(record) {
		_, ok := s.prints[record.Hash]
		if ok {
			s.prints[record.Hash] = append(s.prints[record.Hash], record)
		} else {
			s.prints[record.Hash] = []panako.StoreRecord{record}
		}
	}
}
func (s *MemoryStore) StorePanakoPrints(records []panako.StoreRecord) {
	for _, record := range records {
		s.StorePanakoPrint(record)
	}
}