who
[svn42.git] / 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 }