go/brain/brain.go

   1 // (c) Bernhard Tittelbach, 2013
   2
   3 package brain
   4
   5 import "errors"
   6
   7 type informationtuple struct {
   8     name string
   9     value interface{}
  10 }
  11
  12 type informationretrievalpath struct {
  13     name string
  14     returnpath chan interface{}
  15 }
  16
  17 type hippocampus map[string]interface{}
  18
  19 type Brain struct {
  20     storeTuple chan informationtuple
  21     retrieveValue chan informationretrievalpath
  22     shutdown chan bool
  23 }
  24
  25 func New() *Brain {
  26     b := new(Brain)
  27     b.storeTuple = make(chan informationtuple)
  28     b.retrieveValue = make(chan informationretrievalpath)
  29     go b.runBrain()
  30     return b
  31 }
  32
  33 func (b *Brain) runBrain() {
  34     var h hippocampus = make(hippocampus)
  35     for {
  36         select {
  37             case newtuple := <- b.storeTuple:
  38                 h[newtuple.name] = newtuple.value
  39
  40             case retrievvalue := <- b.retrieveValue:
  41                 v, e := h[retrievvalue.name]
  42                 if e {
  43                     retrievvalue.returnpath <- v
  44                 } else {
  45                     retrievvalue.returnpath <- nil
  46                 }
  47
  48             case <- b.shutdown:
  49                 break
  50         }
  51     }
  52 }
  53
  54 func (b *Brain) Shutdown() {
  55     b.shutdown <- true
  56 }
  57
  58 func (b *Brain) Oboite(name string, value interface{}) {
  59     b.storeTuple <- informationtuple{name, value}
  60 }
  61
  62 func (b *Brain) OmoiDashite(name string) (interface{}, error) {
  63     rc := make(chan interface{})
  64     b.retrieveValue <- informationretrievalpath{name, rc}
  65     v := <- rc
  66     if v == nil {
  67         return v, errors.New("name not in brain")
  68     }
  69     return v, nil
  70 }
  71
  72 func (b *Brain) OmoiDashiteBool(name string) (bool, error) {
  73     v, e := b.OmoiDashite(name)
  74     if e != nil {
  75         return false, e
  76     }
  77     vc, ok := v.(bool)
  78     if !ok {
  79         return false, errors.New(name + " does not have type bool")
  80     }
  81     return vc, nil
  82 }
  83
  84 func (b *Brain) OmoiDashiteInt(name string) (int, error) {
  85     v, e := b.OmoiDashite(name)
  86     if e != nil {
  87         return 0, e
  88     }
  89     vc, ok := v.(int)
  90     if !ok {
  91         return 0, errors.New(name + " does not have type int")
  92     }
  93     return vc, nil
  94 }
  95
  96 func (b *Brain) OmoiDashiteFloat(name string) (float64, error) {
  97     v, e := b.OmoiDashite(name)
  98     if e != nil {
  99         return 0, e
 100     }
 101     vc, ok := v.(float64)
 102     if !ok {
 103         return 0, errors.New(name + " does not have type float64")
 104     }
 105     return vc, nil
 106 }
 107
 108 func (b *Brain) OmoiDashiteString(name string) (string, error) {
 109     v, e := b.OmoiDashite(name)
 110     if e != nil {
 111         return "", e
 112     }
 113     vc, ok := v.(string)
 114     if !ok {
 115         return "", errors.New(name + " does not have type string")
 116     }
 117     return vc, nil
 118 }