1 package org.sourceforge.jemm.database.components;
2
3 import java.util.Collection;
4
5 import org.sourceforge.jemm.collections.internal.ClearRequest;
6 import org.sourceforge.jemm.collections.internal.ContainsRequest;
7 import org.sourceforge.jemm.collections.internal.ContainsResponse;
8 import org.sourceforge.jemm.collections.internal.SizeRequest;
9 import org.sourceforge.jemm.collections.internal.SizeResponse;
10 import org.sourceforge.jemm.collections.internal.StoredValue;
11 import org.sourceforge.jemm.collections.internal.VoidResponse;
12 import org.sourceforge.jemm.collections.internal.map.ContainsValueRequest;
13 import org.sourceforge.jemm.collections.internal.map.MapGetRequest;
14 import org.sourceforge.jemm.collections.internal.map.MapGetResponse;
15 import org.sourceforge.jemm.collections.internal.map.MapKeySetRequest;
16 import org.sourceforge.jemm.collections.internal.map.MapKeySetResponse;
17 import org.sourceforge.jemm.collections.internal.map.MapPutIfAbsentRequest;
18 import org.sourceforge.jemm.collections.internal.map.MapPutIfAbsentResponse;
19 import org.sourceforge.jemm.collections.internal.map.MapPutRequest;
20 import org.sourceforge.jemm.collections.internal.map.MapPutResponse;
21 import org.sourceforge.jemm.collections.internal.map.MapRemoveKVRequest;
22 import org.sourceforge.jemm.collections.internal.map.MapRemoveKVResponse;
23 import org.sourceforge.jemm.collections.internal.map.MapRemoveRequest;
24 import org.sourceforge.jemm.collections.internal.map.MapRemoveResponse;
25 import org.sourceforge.jemm.collections.internal.map.MapReplaceKONRequest;
26 import org.sourceforge.jemm.collections.internal.map.MapReplaceKONResponse;
27 import org.sourceforge.jemm.collections.internal.map.MapReplaceKVRequest;
28 import org.sourceforge.jemm.collections.internal.map.MapReplaceKVResponse;
29 import org.sourceforge.jemm.collections.internal.map.MapValuesRequest;
30 import org.sourceforge.jemm.collections.internal.map.MapValuesResponse;
31 import org.sourceforge.jemm.database.ClassId;
32 import org.sourceforge.jemm.database.ClientId;
33 import org.sourceforge.jemm.database.ObjectAccessor;
34 import org.sourceforge.jemm.database.components.interfaces.DBClientRefHandler;
35 import org.sourceforge.jemm.database.components.types.StoredListObject;
36 import org.sourceforge.jemm.database.components.types.StoredMapObject;
37 import org.sourceforge.jemm.database.components.types.StoredObject;
38 import org.sourceforge.jemm.database.components.types.StoredSetObject;
39 import org.sourceforge.jemm.lifecycle.TypeRequest;
40 import org.sourceforge.jemm.lifecycle.TypeResponse;
41 import org.sourceforge.jemm.types.ID;
42
43 public class DefaultDBMapTypeHandler extends TypeHandler {
44 private final ObjectAccessor objectAccessor;
45 private final ClassId setClassId;
46 private final ClassId listClassId;
47
48 public DefaultDBMapTypeHandler(ClassId classId,ObjectAccessor objectAccessor,DBClientRefHandler clientRefHandler,
49 ClassId setClassId,ClassId listClassId) {
50 super(classId,clientRefHandler);
51 this.objectAccessor = objectAccessor;
52 this.setClassId = setClassId;
53 this.listClassId = listClassId;
54 }
55
56 private StoredMapObject getMap(ID id) {
57 return objectAccessor.getMapObject(id);
58 }
59
60 public void clear(ClientId clientId,ID id) {
61 StoredMapObject smo = getMap(id);
62 try {
63 smo.clear();
64 }finally {
65 objectAccessor.release(smo);
66 }
67 }
68
69 public ContainsResponse containsKey(ClientId clientId,ID id, ContainsRequest keyReq) {
70 StoredMapObject smo = getMap(id);
71 try {
72 ContainsResponse resp = smo.containsKey(keyReq);
73 return recordReferences(clientId,resp);
74 }finally {
75 objectAccessor.release(smo);
76 }
77 }
78
79 public ContainsResponse containsValue(ClientId clientId,ID id, ContainsValueRequest valueReq) {
80 StoredMapObject smo = getMap(id);
81 try {
82 ContainsResponse resp = smo.containsValue(valueReq);
83 return recordReferences(clientId,resp);
84 }finally {
85 objectAccessor.release(smo);
86 }
87 }
88
89 public MapGetResponse get(ClientId clientId,ID id,MapGetRequest getReq) {
90 StoredMapObject smo = getMap(id);
91 try {
92 MapGetResponse resp = smo.get(getReq);
93 return recordReferences(clientId,resp);
94 }finally {
95 objectAccessor.release(smo);
96 }
97 }
98
99 public boolean isEmpty(ClientId clientId,ID id) {
100 StoredMapObject smo = getMap(id);
101 try {
102 return smo.isEmpty();
103 }finally {
104 objectAccessor.release(smo);
105 }
106 }
107
108 public ID keySet(ClientId clientId,ID id) {
109 StoredMapObject smo = null;
110 ID setId = null;
111 StoredSetObject set = null;
112 try {
113 smo = getMap(id);
114 setId = objectAccessor.createObject(clientId, setClassId);
115 set = objectAccessor.getSetObject(setId);
116 Collection<StoredValue> keys = smo.getKeys();
117 set.addAllInternal(keys);
118 return recordReference(clientId, setId);
119 }catch(Exception e) {
120 e.printStackTrace();
121 throw new RuntimeException(e);
122
123 }finally {
124 if(smo != null)
125 objectAccessor.release(smo);
126 if(set != null)
127 objectAccessor.release(set);
128 }
129 }
130
131 public MapPutResponse put(ClientId clientId,ID id,MapPutRequest req) {
132 StoredMapObject smo = getMap(id);
133 try {
134 return recordReferences(clientId,smo.put(req));
135 }finally {
136 objectAccessor.release(smo);
137 }
138 }
139
140 public MapPutIfAbsentResponse putIfAbsent(ClientId clientId,ID id,MapPutIfAbsentRequest req) {
141 StoredMapObject smo = getMap(id);
142 try {
143 MapPutIfAbsentResponse resp = smo.putIfAbsent(req);
144 return recordReferences(clientId,resp);
145 }finally {
146 objectAccessor.release(smo);
147 }
148 }
149
150 public MapRemoveKVResponse remove(ClientId clientId,ID id,MapRemoveKVRequest removeKVReq) {
151 StoredMapObject smo = getMap(id);
152 try {
153 MapRemoveKVResponse resp = smo.remove(removeKVReq);
154 return recordReferences(clientId,resp);
155 }finally {
156 objectAccessor.release(smo);
157 }
158 }
159
160 public MapRemoveResponse remove(ClientId clientId,ID id,MapRemoveRequest removeReq) {
161 StoredMapObject smo = getMap(id);
162 try {
163 MapRemoveResponse res = smo.remove(removeReq);
164 return recordReferences(clientId, res);
165 }finally {
166 objectAccessor.release(smo);
167 }
168 }
169
170 public MapReplaceKVResponse replace(ClientId clientId,ID id, MapReplaceKVRequest req) {
171 StoredMapObject smo = getMap(id);
172 try {
173 MapReplaceKVResponse result = smo.replace(req);
174 return recordReferences(clientId, result);
175 }finally {
176 objectAccessor.release(smo);
177 }
178 }
179
180 public MapReplaceKONResponse replace(ClientId clientId,ID id, MapReplaceKONRequest req) {
181 StoredMapObject smo = getMap(id);
182 try {
183 MapReplaceKONResponse result = smo.replace(req);
184 return recordReferences(clientId, result);
185 }finally {
186 objectAccessor.release(smo);
187 }
188 }
189
190 public int size(ClientId clientId,ID id) {
191 StoredMapObject smo = getMap(id);
192 try {
193 return smo.size();
194 }finally {
195 objectAccessor.release(smo);
196 }
197 }
198
199 public ID values(ClientId clientId,ID id) {
200 StoredMapObject smo = getMap(id);
201 ID listId = objectAccessor.createObject(clientId, listClassId);
202 StoredListObject list = objectAccessor.getListObject(listId);
203 try {
204 Collection<StoredValue> values = smo.values();
205 list.addAll(values.toArray(new StoredValue[0]));
206 return recordReference(clientId, listId);
207 }finally {
208 objectAccessor.release(list);
209 objectAccessor.release(smo);
210 }
211 }
212
213 @Override
214 public StoredObject createStorageObject(ID id) {
215 return new StoredMapObject(id,classId);
216 }
217
218 @Override
219 public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
220 ID id, TypeRequest<?> request) {
221
222 if(request instanceof ClearRequest) {
223 clear(clientId, id);
224 return new VoidResponse();
225 } else if(request instanceof MapGetRequest) {
226 return get(clientId,id,(MapGetRequest) request);
227 } else if(request instanceof MapRemoveRequest) {
228 return remove(clientId,id,(MapRemoveRequest) request);
229 } else if(request instanceof MapRemoveKVRequest) {
230 return remove(clientId,id,(MapRemoveKVRequest) request);
231 } else if(request instanceof SizeRequest) {
232 return new SizeResponse(size(clientId,id));
233 } else if(request instanceof MapPutRequest) {
234 return put(clientId,id,(MapPutRequest) request);
235 } else if(request instanceof ContainsRequest) {
236 return containsKey(clientId,id,(ContainsRequest) request);
237 } else if(request instanceof MapReplaceKVRequest) {
238 return replace(clientId,id,(MapReplaceKVRequest) request);
239 } else if(request instanceof MapReplaceKONRequest) {
240 return replace(clientId,id,(MapReplaceKONRequest) request);
241 } else if(request instanceof MapPutIfAbsentRequest) {
242 return putIfAbsent(clientId,id,(MapPutIfAbsentRequest) request);
243 } else if(request instanceof ContainsValueRequest) {
244 return containsValue(clientId,id,(ContainsValueRequest) request);
245 } else if(request instanceof MapKeySetRequest) {
246 MapKeySetResponse resp = new MapKeySetResponse(keySet(clientId,id));
247 return recordReference(clientId, resp);
248 } else if(request instanceof MapValuesRequest) {
249 MapValuesResponse resp = new MapValuesResponse(values(clientId,id));
250 return recordReference(clientId, resp);
251 }
252
253 throw new IllegalStateException("Unhandled request type " + request.getClass());
254 }
255 }