source: java/main/src/main/java/com/framsticks/params/FreeAccess.java @ 107

Last change on this file since 107 was 107, checked in by psniegowski, 11 years ago

HIGHLIGHTS:

  • add SimultorProviders? hierarchy
  • start Framsticks server over SSH
  • FJF compatible with Framsticks 4.0rc3
  • reading and writing of standard.expt
  • a proof-of-concept implementation of StandardExperiment?

CHANGELOG:
Optionally return FreeAccess? from registry.

Add SimulatorRange?.

StandardExperiment? with genotypes circulation.

Automate registration around StandardState?.

More improvements to StandardExperiment?.

Skeleton version of StandardExperiment?.

Test saving of StandardState?.

Standard experiment state is being loaded.

More development towards StandardState? reading.

Work on reading standard experiment state.

Add classes for standard experiment.

Update example standard.expt

Add FreeAccess? and FreeObject?.

Made compatible with version 4.0rc3

Change deserialization policy.

Improve SSH support.

Working running simulator over SSH.

Fix joining bug in Experiment.

Working version of SimulatorRunner?.

Add more SimulatorProviders?.

Working PrimeExperimentTest? with 4.0rc3

Add references to deserialization.

Add OpaqueObject? and it's serialization.

Add deserialization of dictionaries.

Partial implementation of deserialization.

Add more tests for deserialization.

Prepare tests for deserialization.

Add proper result to prime experiment test.

Minor fixes to simulators providers.

Draft version of SimulatorProvider?.

Add SimulatorProvider? interface.

File size: 4.0 KB
Line 
1package com.framsticks.params;
2
3import java.util.Iterator;
4import java.util.Map;
5
6import com.framsticks.params.types.EventParam;
7import com.framsticks.params.types.ObjectParam;
8import com.framsticks.params.types.ProcedureParam;
9import com.framsticks.params.types.UniversalParam;
10import com.framsticks.util.UnimplementedException;
11
12public class FreeAccess implements ObjectAccess {
13
14        protected FreeObject object;
15
16        protected final String typeName;
17
18        /**
19         * @param typeName
20         */
21        public FreeAccess(String typeName) {
22                this.typeName = typeName;
23        }
24
25        @Override
26        public Param getParam(int i) {
27                throw new InvalidOperationException();
28        }
29
30        @Override
31        public Param getParam(String id) {
32                return Param.build().type(UniversalParam.class).idAndName(id).finish();
33        }
34
35        @Override
36        public int getParamCount() {
37                return object.size();
38        }
39
40        @Override
41        public Iterable<Param> getParams() {
42                return new Iterable<Param>() {
43
44                        @Override
45                        public Iterator<Param> iterator() {
46                                return new Iterator<Param>() {
47
48                                        protected final Iterator<Map.Entry<String, Object>> internal = object.iterator();
49
50                                        @Override
51                                        public boolean hasNext() {
52                                                return internal.hasNext();
53                                        }
54
55                                        @Override
56                                        public Param next() {
57                                                return Param.build().idAndName(internal.next().getKey()).type(UniversalParam.class).finish(Param.class);
58                                        }
59
60                                        @Override
61                                        public void remove() {
62                                                throw new UnimplementedException().msg("remove element from FreeAccess").arg("access", FreeAccess.this);
63                                        }
64                                };
65                        }
66                };
67        }
68
69        @Override
70        public String getTypeId() {
71                return typeName;
72        }
73
74        @Override
75        public Object call(String id, Object... arguments) {
76                throw new InvalidOperationException().msg("properties access does not support calling methods").arg("id", id);
77        }
78
79        @Override
80        public Object call(ProcedureParam param, Object... arguments) {
81                throw new InvalidOperationException().msg("properties access does not support calling methods").arg("param", param);
82        }
83
84        @Override
85        public <T> T get(int i, Class<T> type) {
86                throw new InvalidOperationException();
87        }
88
89        @Override
90        public <T> T get(String id, Class<T> type) {
91                return object.get(id, type);
92        }
93
94        @Override
95        public <T> T get(ValueParam param, Class<T> type) {
96                return get(param.getId(), type);
97        }
98
99        @Override
100        public <T> int set(int i, T value) {
101                throw new InvalidOperationException();
102        }
103
104        @Override
105        public <T> int set(String id, T value) {
106                object.set(id, (value instanceof String) ? ParamsUtil.deserialize((String) value) : value);
107                return 0;
108        }
109
110        @Override
111        public <T> int set(ValueParam param, T value) {
112                return set(param.getId(), value);
113        }
114
115        @Override
116        public void reg(EventParam param, EventListener<?> listener) {
117                throw new InvalidOperationException().msg("properties access does not support registering events").arg("param", param).arg("access", this);
118        }
119
120        @Override
121        public void regRemove(EventParam param, EventListener<?> listener) {
122                throw new InvalidOperationException().msg("properties access does not support registering events").arg("param", param).arg("access", this);
123        }
124
125        @Override
126        public void clearValues() {
127                object.clear();
128        }
129
130        @Override
131        public Access select(Object object) {
132                this.object = ParamsUtil.selectObjectForAccess(this, object, FreeObject.class);
133                return this;
134        }
135
136        @Override
137        public Object getSelected() {
138                return object;
139        }
140
141        @Override
142        public Access cloneAccess() {
143                return new FreeAccess(typeName);
144        }
145
146        @Override
147        public Object createAccessee() {
148                return new FreeObject(typeName);
149        }
150
151        @Override
152        public FramsClass getFramsClass() {
153                throw new InvalidOperationException();
154        }
155
156        @Override
157        public void tryAutoAppend(Object object) {
158                throw new InvalidOperationException();
159        }
160
161        @Override
162        public int getCompositeParamCount() {
163                return 0;
164        }
165
166        @Override
167        public CompositeParam getCompositeParam(int number) {
168                throw new InvalidOperationException();
169        }
170
171        @Override
172        public ParamBuilder buildParam(ParamBuilder builder) {
173                return builder.name(typeName).type(ObjectParam.class).containedTypeName(typeName);
174        }
175
176        @Override
177        public String toString() {
178                return "FreeAccess[" + typeName + "]";
179        }
180
181}
Note: See TracBrowser for help on using the repository browser.