package service
|
|
import (
|
"apsClient/model"
|
"apsClient/model/response"
|
"fmt"
|
"sync"
|
)
|
|
type CacheStore struct {
|
cache map[string]interface{}
|
mu sync.Mutex
|
}
|
|
var defaultCacheStore *CacheStore
|
|
func init() {
|
defaultCacheStore = newCacheManager()
|
}
|
func newCacheManager() *CacheStore {
|
return &CacheStore{
|
cache: make(map[string]interface{}),
|
}
|
}
|
|
func (cm *CacheStore) Get(key string) (interface{}, bool) {
|
cm.mu.Lock()
|
defer cm.mu.Unlock()
|
|
conn, ok := cm.cache[key]
|
return conn, ok
|
}
|
|
func (cm *CacheStore) Add(key string, value interface{}) {
|
cm.mu.Lock()
|
defer cm.mu.Unlock()
|
cm.cache[key] = value
|
}
|
|
func (cm *CacheStore) Remove(key string) {
|
cm.mu.Lock()
|
defer cm.mu.Unlock()
|
delete(cm.cache, key)
|
}
|
|
const (
|
PlcCacheKey = "plc:%v"
|
CurrentTaskCacheKey = "current_task"
|
CurrentProgressCacheKey = "current_progress"
|
)
|
|
func PlcCacheGet(key string) (interface{}, bool) {
|
return defaultCacheStore.Get(fmt.Sprintf(PlcCacheKey, key))
|
}
|
|
func PlcCacheSet(key string, value interface{}) {
|
defaultCacheStore.Add(fmt.Sprintf(PlcCacheKey, key), value)
|
}
|
|
func TaskCacheSet(value *response.TaskData) {
|
defaultCacheStore.Add(CurrentTaskCacheKey, value)
|
}
|
|
func TaskCacheUnset() {
|
defaultCacheStore.Remove(CurrentTaskCacheKey)
|
}
|
|
func TaskCacheGet() (*response.TaskData, bool) {
|
if v, ok := defaultCacheStore.Get(CurrentTaskCacheKey); ok {
|
return v.(*response.TaskData), ok
|
}
|
return nil, false
|
}
|
|
func ProgressCacheGet() (*model.ProductionProgress, bool) {
|
if v, ok := defaultCacheStore.Get(CurrentProgressCacheKey); ok {
|
return v.(*model.ProductionProgress), ok
|
}
|
return nil, false
|
}
|
|
func ProgressCacheSet(value *model.ProductionProgress) {
|
defaultCacheStore.Add(CurrentProgressCacheKey, value)
|
}
|
|
func ProgressCacheUnset() {
|
defaultCacheStore.Remove(CurrentProgressCacheKey)
|
}
|
