go/r3-netstatus/brain/brain.go

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