package protocol import ( "sync" "github.com/status-im/status-go/protocol/encryption/multidevice" "github.com/status-im/status-go/protocol/protobuf" ) /* |-------------------------------------------------------------------------- | chatMap |-------------------------------------------------------------------------- | | A sync.Map wrapper for a specific mapping of map[string]*Chat | */ type chatMap struct { sm sync.Map } func (cm *chatMap) Load(chatID string) (*Chat, bool) { chat, ok := cm.sm.Load(chatID) if chat == nil { return nil, ok } return chat.(*Chat), ok } func (cm *chatMap) Store(chatID string, chat *Chat) { cm.sm.Store(chatID, chat) } func (cm *chatMap) Range(f func(chatID string, chat *Chat) (shouldContinue bool)) { nf := func(key, value interface{}) (shouldContinue bool) { return f(key.(string), value.(*Chat)) } cm.sm.Range(nf) } func (cm *chatMap) Delete(chatID string) { cm.sm.Delete(chatID) } /* |-------------------------------------------------------------------------- | contactMap |-------------------------------------------------------------------------- | | A sync.Map wrapper for a specific mapping of map[string]*Contact | */ type contactMap struct { sm sync.Map } func (cm *contactMap) Load(contactID string) (*Contact, bool) { contact, ok := cm.sm.Load(contactID) if contact == nil { return nil, ok } return contact.(*Contact), ok } func (cm *contactMap) Store(contactID string, contact *Contact) { cm.sm.Store(contactID, contact) } func (cm *contactMap) Range(f func(contactID string, contact *Contact) (shouldContinue bool)) { nf := func(key, value interface{}) (shouldContinue bool) { return f(key.(string), value.(*Contact)) } cm.sm.Range(nf) } func (cm *contactMap) Delete(contactID string) { cm.sm.Delete(contactID) } /* |-------------------------------------------------------------------------- | systemMessageTranslationsMap |-------------------------------------------------------------------------- | | A sync.Map wrapper for the specific mapping of map[protobuf.MembershipUpdateEvent_EventType]string | */ type systemMessageTranslationsMap struct { sm sync.Map } func (smtm *systemMessageTranslationsMap) Init(set map[protobuf.MembershipUpdateEvent_EventType]string) { for eventType, message := range set { smtm.Store(eventType, message) } } func (smtm *systemMessageTranslationsMap) Load(eventType protobuf.MembershipUpdateEvent_EventType) (string, bool) { message, ok := smtm.sm.Load(eventType) if message == nil { return "", ok } return message.(string), ok } func (smtm *systemMessageTranslationsMap) Store(eventType protobuf.MembershipUpdateEvent_EventType, message string) { smtm.sm.Store(eventType, message) } func (smtm *systemMessageTranslationsMap) Range(f func(eventType protobuf.MembershipUpdateEvent_EventType, message string) (shouldContinue bool)) { nf := func(key, value interface{}) (shouldContinue bool) { return f(key.(protobuf.MembershipUpdateEvent_EventType), value.(string)) } smtm.sm.Range(nf) } func (smtm *systemMessageTranslationsMap) Delete(eventType protobuf.MembershipUpdateEvent_EventType) { smtm.sm.Delete(eventType) } /* |-------------------------------------------------------------------------- | installationMap |-------------------------------------------------------------------------- | | A sync.Map wrapper for the specific mapping of map[string]*multidevice.Installation | */ type installationMap struct { sm sync.Map } func (im *installationMap) Load(installationID string) (*multidevice.Installation, bool) { installation, ok := im.sm.Load(installationID) if installation == nil { return nil, ok } return installation.(*multidevice.Installation), ok } func (im *installationMap) Store(installationID string, installation *multidevice.Installation) { im.sm.Store(installationID, installation) } func (im *installationMap) Range(f func(installationID string, installation *multidevice.Installation) (shouldContinue bool)) { nf := func(key, value interface{}) (shouldContinue bool) { return f(key.(string), value.(*multidevice.Installation)) } im.sm.Range(nf) } func (im *installationMap) Delete(installationID string) { im.sm.Delete(installationID) } func (im *installationMap) Empty() bool { count := 0 im.Range(func(installationID string, installation *multidevice.Installation) (shouldContinue bool) { count++ return false }) return count == 0 } func (im *installationMap) Len() int { count := 0 im.Range(func(installationID string, installation *multidevice.Installation) (shouldContinue bool) { count++ return true }) return count } /* |-------------------------------------------------------------------------- | stringBoolMap |-------------------------------------------------------------------------- | | A sync.Map wrapper for the specific mapping of map[string]bool | */ type stringBoolMap struct { sm sync.Map } func (sbm *stringBoolMap) Load(key string) (bool, bool) { state, ok := sbm.sm.Load(key) if state == nil { return false, ok } return state.(bool), ok } func (sbm *stringBoolMap) Store(key string, value bool) { sbm.sm.Store(key, value) } func (sbm *stringBoolMap) Range(f func(key string, value bool) (shouldContinue bool)) { nf := func(key, value interface{}) (shouldContinue bool) { return f(key.(string), value.(bool)) } sbm.sm.Range(nf) } func (sbm *stringBoolMap) Delete(key string) { sbm.sm.Delete(key) } func (sbm *stringBoolMap) Len() int { count := 0 sbm.Range(func(key string, value bool) (shouldContinue bool) { count++ return true }) return count }