1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 2002-2009 Oracle. All rights reserved.
*
* $Id$
*/
package collections.ship.marshal;
import com.sleepycat.bind.EntityBinding;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.ClassCatalog;
import com.sleepycat.bind.serial.TupleSerialBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.bind.tuple.TupleInput;
import com.sleepycat.bind.tuple.TupleOutput;
import com.sleepycat.collections.StoredSortedMap;
import com.sleepycat.collections.StoredSortedValueSet;
import com.sleepycat.util.RuntimeExceptionWrapper;
/**
* SampleViews defines the data bindings and collection views for the sample
* database.
*
* @author Mark Hayes
*/
public class SampleViews {
private StoredSortedMap partMap;
private StoredSortedMap supplierMap;
private StoredSortedMap shipmentMap;
private StoredSortedMap shipmentByPartMap;
private StoredSortedMap shipmentBySupplierMap;
private StoredSortedMap supplierByCityMap;
/**
* Create the data bindings and collection views.
*/
public SampleViews(SampleDatabase db) {
// Create the data bindings.
// In this sample, EntityBinding classes are used to bind the stored
// key/data entry pair to a combined data object; a "tricky" binding
// that uses transient fields is used--see PartBinding, etc, for
// details. For keys, a one-to-one binding is implemented with
// EntryBinding classes to bind the stored tuple entry to a key Object.
//
ClassCatalog catalog = db.getClassCatalog();
EntryBinding partKeyBinding =
new MarshalledKeyBinding(PartKey.class);
EntityBinding partDataBinding =
new MarshalledEntityBinding(catalog, Part.class);
EntryBinding supplierKeyBinding =
new MarshalledKeyBinding(SupplierKey.class);
EntityBinding supplierDataBinding =
new MarshalledEntityBinding(catalog, Supplier.class);
EntryBinding shipmentKeyBinding =
new MarshalledKeyBinding(ShipmentKey.class);
EntityBinding shipmentDataBinding =
new MarshalledEntityBinding(catalog, Shipment.class);
EntryBinding cityKeyBinding =
TupleBinding.getPrimitiveBinding(String.class);
// Create map views for all stores and indices.
// StoredSortedMap is used since the stores and indices are ordered
// (they use the DB_BTREE access method).
//
partMap =
new StoredSortedMap(db.getPartDatabase(),
partKeyBinding, partDataBinding, true);
supplierMap =
new StoredSortedMap(db.getSupplierDatabase(),
supplierKeyBinding, supplierDataBinding, true);
shipmentMap =
new StoredSortedMap(db.getShipmentDatabase(),
shipmentKeyBinding, shipmentDataBinding, true);
shipmentByPartMap =
new StoredSortedMap(db.getShipmentByPartDatabase(),
partKeyBinding, shipmentDataBinding, true);
shipmentBySupplierMap =
new StoredSortedMap(db.getShipmentBySupplierDatabase(),
supplierKeyBinding, shipmentDataBinding, true);
supplierByCityMap =
new StoredSortedMap(db.getSupplierByCityDatabase(),
cityKeyBinding, supplierDataBinding, true);
}
// The views returned below can be accessed using the java.util.Map or
// java.util.Set interfaces, or using the StoredSortedMap and
// StoredValueSet classes, which provide additional methods. The entity
// sets could be obtained directly from the Map.values() method but
// convenience methods are provided here to return them in order to avoid
// down-casting elsewhere.
/**
* Return a map view of the part storage container.
*/
public StoredSortedMap getPartMap() {
return partMap;
}
/**
* Return a map view of the supplier storage container.
*/
public StoredSortedMap getSupplierMap() {
return supplierMap;
}
/**
* Return a map view of the shipment storage container.
*/
public StoredSortedMap getShipmentMap() {
return shipmentMap;
}
/**
* Return an entity set view of the part storage container.
*/
public StoredSortedValueSet getPartSet() {
return (StoredSortedValueSet) partMap.values();
}
/**
* Return an entity set view of the supplier storage container.
*/
public StoredSortedValueSet getSupplierSet() {
return (StoredSortedValueSet) supplierMap.values();
}
/**
* Return an entity set view of the shipment storage container.
*/
public StoredSortedValueSet getShipmentSet() {
return (StoredSortedValueSet) shipmentMap.values();
}
/**
* Return a map view of the shipment-by-part index.
*/
public StoredSortedMap getShipmentByPartMap() {
return shipmentByPartMap;
}
/**
* Return a map view of the shipment-by-supplier index.
*/
public StoredSortedMap getShipmentBySupplierMap() {
return shipmentBySupplierMap;
}
/**
* Return a map view of the supplier-by-city index.
*/
public final StoredSortedMap getSupplierByCityMap() {
return supplierByCityMap;
}
/**
* MarshalledKeyBinding is used to bind the stored key tuple entry to a key
* object representation. To do this, it calls the MarshalledKey interface
* implemented by the key class.
*/
private static class MarshalledKeyBinding extends TupleBinding {
private Class keyClass;
/**
* Construct the binding object.
*/
private MarshalledKeyBinding(Class keyClass) {
// The key class will be used to instantiate the key object.
//
if (!MarshalledKey.class.isAssignableFrom(keyClass)) {
throw new IllegalArgumentException(keyClass.toString() +
" does not implement MarshalledKey");
}
this.keyClass = keyClass;
}
/**
* Create the key object from the stored key tuple entry.
*/
public Object entryToObject(TupleInput input) {
try {
MarshalledKey key = (MarshalledKey) keyClass.newInstance();
key.unmarshalKey(input);
return key;
} catch (IllegalAccessException e) {
throw new RuntimeExceptionWrapper(e);
} catch (InstantiationException e) {
throw new RuntimeExceptionWrapper(e);
}
}
/**
* Create the stored key tuple entry from the key object.
*/
public void objectToEntry(Object object, TupleOutput output) {
MarshalledKey key = (MarshalledKey) object;
key.marshalKey(output);
}
}
/**
* MarshalledEntityBinding is used to bind the stored key/data entry pair
* to a combined to an entity object representation. To do this, it calls
* the MarshalledEnt interface implemented by the entity class.
*
* <p> The binding is "tricky" in that it uses the entity class for both
* the stored data entry and the combined entity object. To do this,
* entity's key field(s) are transient and are set by the binding after the
* data object has been deserialized. This avoids the use of a "data" class
* completely. </p>
*/
private static class MarshalledEntityBinding extends TupleSerialBinding {
/**
* Construct the binding object.
*/
private MarshalledEntityBinding(ClassCatalog classCatalog,
Class entityClass) {
super(classCatalog, entityClass);
// The entity class will be used to instantiate the entity object.
//
if (!MarshalledEnt.class.isAssignableFrom(entityClass)) {
throw new IllegalArgumentException(entityClass.toString() +
" does not implement MarshalledEnt");
}
}
/**
* Create the entity by combining the stored key and data.
* This "tricky" binding returns the stored data as the entity, but
* first it sets the transient key fields from the stored key.
*/
public Object entryToObject(TupleInput tupleInput, Object javaInput) {
MarshalledEnt entity = (MarshalledEnt) javaInput;
entity.unmarshalPrimaryKey(tupleInput);
return entity;
}
/**
* Create the stored key from the entity.
*/
public void objectToKey(Object object, TupleOutput output) {
MarshalledEnt entity = (MarshalledEnt) object;
entity.marshalPrimaryKey(output);
}
/**
* Return the entity as the stored data. There is nothing to do here
* since the entity's key fields are transient.
*/
public Object objectToData(Object object) {
return object;
}
}
}
|
