fork download
copy 
  1. type DataManager struct {
  2.     /** This contain connection to know dataStore **/
  3.     m_dataStores map[string]DataStore
  4.  
  5.     /** That channel is use to access the dataStores map **/
  6.     m_dataStoreChan chan map[string]interface{}
  7. }
  8.  
  9. func newDataManager() *DataManager {
  10.     dataManager := new(DataManager)
  11.     dataManager.m_dataStores = make(map[string]DataStore)
  12.     dataManager.m_dataStoreChan = make(chan map[string]interface{}, 0)
  13.     // Concurrency...
  14.     go func() {
  15.         for {
  16.             select {
  17.             case op := <-dataManager.m_dataStoreChan:
  18.                 if op["op"] == "getDataStore" {
  19.                     storeId := op["storeId"].(string)
  20.                     op["store"].(chan DataStore) <- dataManager.m_dataStores[storeId]
  21.                 } else if op["op"] == "getDataStores" {
  22.                     stores := make([]DataStore, 0)
  23.                     for _, store := range dataManager.m_dataStores {
  24.                         stores = append(stores, store)
  25.                     }
  26.                     op["stores"].(chan []DataStore) <- stores
  27.                 } else if op["op"] == "setDataStore" {
  28.                     store := op["store"].(DataStore)
  29.                     dataManager.m_dataStores[store.GetId()] = store
  30.                 } else if op["op"] == "removeDataStore" {
  31.                     storeId := op["storeId"].(string)
  32.                     delete(dataManager.m_dataStores, storeId)
  33.                 }
  34.             }
  35.         }
  36.     }()
  37.  
  38.     return dataManager
  39. }
  40.  
  41. /**
  42.  * Access Map functions...
  43.  */
  44. func (this *DataManager) getDataStore(id string) DataStore {
  45.     arguments := make(map[string]interface{})
  46.     arguments["op"] = "getDataStore"
  47.     arguments["storeId"] = id
  48.     result := make(chan DataStore)
  49.     arguments["store"] = result
  50.     this.m_dataStoreChan <- arguments
  51.     return <-result
  52. }
  53.  
  54. func (this *DataManager) getDataStores() []DataStore {
  55.     arguments := make(map[string]interface{})
  56.     arguments["op"] = "getDataStores"
  57.     result := make(chan []DataStore)
  58.     arguments["stores"] = result
  59.     this.m_dataStoreChan <- arguments
  60.     return <-result
  61. }
  62.  
  63. func (this *DataManager) setDataStore(store DataStore) {
  64.     arguments := make(map[string]interface{})
  65.     arguments["op"] = "setDataStore"
  66.     arguments["store"] = store
  67.     this.m_dataStoreChan <- arguments
  68. }
  69.  
  70. func (this *DataManager) removeDataStore(id string) {
  71.     arguments := make(map[string]interface{})
  72.     arguments["storeId"] = id
  73.     arguments["op"] = "removeDataStore"
  74.     this.m_dataStoreChan <- arguments
  75. }
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
can't load package: package .: 
prog.go:1:1: expected 'package', found 'type'
stdout
copy 
Standard output is empty
https://ideone.com/9SkknR
language:
Go (go 1.12.1)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!