Sync source code from Tizen:BaseHEAD2.0_alphamaster2.0alpha1.0_post

12 files changed, 1433 insertions, 0 deletions

diff --git a/examples_java/src/collections/ship/marshal/MarshalledEnt.java b/examples_java/src/collections/ship/marshal/MarshalledEnt.java
new file mode 100644
index 0000000..fefa2be
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/MarshalledEnt.java
@@ -0,0 +1,42 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * MarshalledEnt is implemented by entity (combined key/data) objects and
+ * called by {@link SampleViews.MarshalledEntityBinding}.  In this sample,
+ * MarshalledEnt is implemented by {@link Part}, {@link Supplier}, and
+ * {@link Shipment}.  This interface is package-protected rather than public
+ * to hide the marshalling interface from other users of the data objects.
+ * Note that a MarshalledEnt must also have a no arguments constructor so
+ * that it can be instantiated by the binding.
+ *
+ * @author Mark Hayes
+ */
+interface MarshalledEnt {
+
+    /**
+     * Extracts the entity's primary key and writes it to the key output.
+     */
+    void marshalPrimaryKey(TupleOutput keyOutput);
+
+    /**
+     * Completes construction of the entity by setting its primary key from the
+     * stored primary key.
+     */
+    void unmarshalPrimaryKey(TupleInput keyInput);
+
+    /**
+     * Extracts the entity's index key and writes it to the key output.
+     */
+    boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput);
+}
diff --git a/examples_java/src/collections/ship/marshal/MarshalledKey.java b/examples_java/src/collections/ship/marshal/MarshalledKey.java
new file mode 100644
index 0000000..8e2d171
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/MarshalledKey.java
@@ -0,0 +1,36 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * MarshalledKey is implemented by key objects and called by {@link
+ * SampleViews.MarshalledKeyBinding}.  In this sample, MarshalledKey is
+ * implemented by {@link PartKey}, {@link SupplierKey}, and {@link
+ * ShipmentKey}.  This interface is package-protected rather than public to
+ * hide the marshalling interface from other users of the data objects.  Note
+ * that a MarshalledKey must also have a no arguments constructor so
+ * that it can be instantiated by the binding.
+ *
+ * @author Mark Hayes
+ */
+interface MarshalledKey {
+
+    /**
+     * Construct the key tuple entry from the key object.
+     */
+    void marshalKey(TupleOutput keyOutput);
+
+    /**
+     * Construct the key object from the key tuple entry.
+     */
+    void unmarshalKey(TupleInput keyInput);
+}
diff --git a/examples_java/src/collections/ship/marshal/Part.java b/examples_java/src/collections/ship/marshal/Part.java
new file mode 100644
index 0000000..ba0a758
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/Part.java
@@ -0,0 +1,116 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.Serializable;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A Part represents the combined key/data pair for a part entity.
+ *
+ * <p> In this sample, Part is bound to the stored key/data entry by
+ * implementing the MarshalledEnt interface, which is called by {@link
+ * SampleViews.MarshalledEntityBinding}. </p>
+ *
+ * <p> The binding is "tricky" in that it uses this class for both the stored
+ * data entry and the combined entity object.  To do this, the key field(s) are
+ * transient and are set by the binding after the data object has been
+ * deserialized. This avoids the use of a PartData class completely. </p>
+ *
+ * <p> Since this class is used directly for data storage, it must be
+ * Serializable. </p>
+ *
+ * @author Mark Hayes
+ */
+public class Part implements Serializable, MarshalledEnt {
+
+    private transient String number;
+    private String name;
+    private String color;
+    private Weight weight;
+    private String city;
+
+    public Part(String number, String name, String color, Weight weight,
+                String city) {
+
+        this.number = number;
+        this.name = name;
+        this.color = color;
+        this.weight = weight;
+        this.city = city;
+    }
+
+    /**
+     * Set the transient key fields after deserializing.  This method is only
+     * called by data bindings.
+     */
+    final void setKey(String number) {
+
+        this.number = number;
+    }
+
+    public final String getNumber() {
+
+        return number;
+    }
+
+    public final String getName() {
+
+        return name;
+    }
+
+    public final String getColor() {
+
+        return color;
+    }
+
+    public final Weight getWeight() {
+
+        return weight;
+    }
+
+    public final String getCity() {
+
+        return city;
+    }
+
+    public String toString() {
+
+        return "[Part: number=" + number +
+               " name=" + name +
+               " color=" + color +
+               " weight=" + weight +
+               " city=" + city + ']';
+    }
+
+    // --- MarshalledEnt implementation ---
+
+    Part() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalPrimaryKey(TupleInput keyInput) {
+
+        this.number = keyInput.readString();
+    }
+
+    public void marshalPrimaryKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.number);
+    }
+
+    public boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput) {
+
+        throw new UnsupportedOperationException(keyName);
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/PartKey.java b/examples_java/src/collections/ship/marshal/PartKey.java
new file mode 100644
index 0000000..fc81535
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/PartKey.java
@@ -0,0 +1,59 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A PartKey serves as the key in the key/data pair for a part entity.
+ *
+ * <p> In this sample, PartKey is bound to the stored key tuple entry by
+ * implementing the MarshalledKey interface, which is called by {@link
+ * SampleViews.MarshalledKeyBinding}. </p>
+ *
+ * @author Mark Hayes
+ */
+public class PartKey implements MarshalledKey {
+
+    private String number;
+
+    public PartKey(String number) {
+
+        this.number = number;
+    }
+
+    public final String getNumber() {
+
+        return number;
+    }
+
+    public String toString() {
+
+        return "[PartKey: number=" + number + ']';
+    }
+
+    // --- MarshalledKey implementation ---
+
+    PartKey() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalKey(TupleInput keyInput) {
+
+        this.number = keyInput.readString();
+    }
+
+    public void marshalKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.number);
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/Sample.java b/examples_java/src/collections/ship/marshal/Sample.java
new file mode 100644
index 0000000..4789921
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/Sample.java
@@ -0,0 +1,236 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.FileNotFoundException;
+import java.util.Iterator;
+import java.util.Set;
+
+import com.sleepycat.collections.TransactionRunner;
+import com.sleepycat.collections.TransactionWorker;
+import com.sleepycat.db.DatabaseException;
+
+/**
+ * Sample is the main entry point for the sample program and may be run as
+ * follows:
+ *
+ * <pre>
+ * java collections.ship.marshal.Sample
+ *      [-h <home-directory> ]
+ * </pre>
+ *
+ * <p> The default for the home directory is ./tmp -- the tmp subdirectory of
+ * the current directory where the sample is run. To specify a different home
+ * directory, use the -home option. The home directory must exist before
+ * running the sample.  To recreate the sample database from scratch, delete
+ * all files in the home directory before running the sample. </p>
+ *
+ * @author Mark Hayes
+ */
+public class Sample {
+
+    private SampleDatabase db;
+    private SampleViews views;
+
+    /**
+     * Run the sample program.
+     */
+    public static void main(String[] args) {
+
+        System.out.println("\nRunning sample: " + Sample.class);
+
+        // Parse the command line arguments.
+        //
+        String homeDir = "./tmp";
+        for (int i = 0; i < args.length; i += 1) {
+            if (args[i].equals("-h") && i < args.length - 1) {
+                i += 1;
+                homeDir = args[i];
+            } else {
+                System.err.println("Usage:\n java " + Sample.class.getName() +
+				   "\n  [-h <home-directory>]");
+                System.exit(2);
+            }
+        }
+
+        // Run the sample.
+        //
+        Sample sample = null;
+        try {
+            sample = new Sample(homeDir);
+            sample.run();
+        } catch (Exception e) {
+            // If an exception reaches this point, the last transaction did not
+            // complete.  If the exception is RunRecoveryException, follow
+            // the Berkeley DB recovery procedures before running again.
+            e.printStackTrace();
+        } finally {
+            if (sample != null) {
+                try {
+                    // Always attempt to close the database cleanly.
+                    sample.close();
+                } catch (Exception e) {
+                    System.err.println("Exception during database close:");
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    /**
+     * Open the database and views.
+     */
+    private Sample(String homeDir)
+        throws DatabaseException, FileNotFoundException {
+
+        db = new SampleDatabase(homeDir);
+        views = new SampleViews(db);
+    }
+
+    /**
+     * Close the database cleanly.
+     */
+    private void close()
+        throws DatabaseException {
+
+        db.close();
+    }
+
+    /**
+     * Run two transactions to populate and print the database.  A
+     * TransactionRunner is used to ensure consistent handling of transactions,
+     * including deadlock retries.  But the best transaction handling mechanism
+     * to use depends on the application.
+     */
+    private void run()
+        throws Exception {
+
+        TransactionRunner runner = new TransactionRunner(db.getEnvironment());
+        runner.run(new PopulateDatabase());
+        runner.run(new PrintDatabase());
+    }
+
+    /**
+     * Populate the database in a single transaction.
+     */
+    private class PopulateDatabase implements TransactionWorker {
+
+        public void doWork()
+            throws Exception {
+            addSuppliers();
+            addParts();
+            addShipments();
+        }
+    }
+
+    /**
+     * Print the database in a single transaction.  All entities are printed
+     * and the indices are used to print the entities for certain keys.
+     *
+     * <p> Note the use of special iterator() methods.  These are used here
+     * with indices to find the shipments for certain keys.</p>
+     */
+    private class PrintDatabase implements TransactionWorker {
+
+        public void doWork()
+            throws Exception {
+            printValues("Parts",
+			views.getPartSet().iterator());
+            printValues("Suppliers",
+			views.getSupplierSet().iterator());
+            printValues("Suppliers for City Paris",
+                        views.getSupplierByCityMap().duplicates(
+                                            "Paris").iterator());
+            printValues("Shipments",
+			views.getShipmentSet().iterator());
+            printValues("Shipments for Part P1",
+                        views.getShipmentByPartMap().duplicates(
+                                            new PartKey("P1")).iterator());
+            printValues("Shipments for Supplier S1",
+                        views.getShipmentBySupplierMap().duplicates(
+                                            new SupplierKey("S1")).iterator());
+        }
+    }
+
+    /**
+     * Populate the part entities in the database.  If the part set is not
+     * empty, assume that this has already been done.
+     */
+    private void addParts() {
+
+        Set parts = views.getPartSet();
+        if (parts.isEmpty()) {
+            System.out.println("Adding Parts");
+            parts.add(new Part("P1", "Nut", "Red",
+			       new Weight(12.0, Weight.GRAMS), "London"));
+            parts.add(new Part("P2", "Bolt", "Green",
+			       new Weight(17.0, Weight.GRAMS), "Paris"));
+            parts.add(new Part("P3", "Screw", "Blue",
+			       new Weight(17.0, Weight.GRAMS), "Rome"));
+            parts.add(new Part("P4", "Screw", "Red",
+			       new Weight(14.0, Weight.GRAMS), "London"));
+            parts.add(new Part("P5", "Cam", "Blue",
+			       new Weight(12.0, Weight.GRAMS), "Paris"));
+            parts.add(new Part("P6", "Cog", "Red",
+			       new Weight(19.0, Weight.GRAMS), "London"));
+        }
+    }
+
+    /**
+     * Populate the supplier entities in the database.  If the supplier set is
+     * not empty, assume that this has already been done.
+     */
+    private void addSuppliers() {
+
+        Set suppliers = views.getSupplierSet();
+        if (suppliers.isEmpty()) {
+            System.out.println("Adding Suppliers");
+            suppliers.add(new Supplier("S1", "Smith", 20, "London"));
+            suppliers.add(new Supplier("S2", "Jones", 10, "Paris"));
+            suppliers.add(new Supplier("S3", "Blake", 30, "Paris"));
+            suppliers.add(new Supplier("S4", "Clark", 20, "London"));
+            suppliers.add(new Supplier("S5", "Adams", 30, "Athens"));
+        }
+    }
+
+    /**
+     * Populate the shipment entities in the database.  If the shipment set
+     * is not empty, assume that this has already been done.
+     */
+    private void addShipments() {
+
+        Set shipments = views.getShipmentSet();
+        if (shipments.isEmpty()) {
+            System.out.println("Adding Shipments");
+            shipments.add(new Shipment("P1", "S1", 300));
+            shipments.add(new Shipment("P2", "S1", 200));
+            shipments.add(new Shipment("P3", "S1", 400));
+            shipments.add(new Shipment("P4", "S1", 200));
+            shipments.add(new Shipment("P5", "S1", 100));
+            shipments.add(new Shipment("P6", "S1", 100));
+            shipments.add(new Shipment("P1", "S2", 300));
+            shipments.add(new Shipment("P2", "S2", 400));
+            shipments.add(new Shipment("P2", "S3", 200));
+            shipments.add(new Shipment("P2", "S4", 200));
+            shipments.add(new Shipment("P4", "S4", 300));
+            shipments.add(new Shipment("P5", "S4", 400));
+        }
+    }
+
+    /**
+     * Print the objects returned by an iterator of entity value objects.
+     */
+    private void printValues(String label, Iterator iterator) {
+
+        System.out.println("\n--- " + label + " ---");
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next().toString());
+        }
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/SampleDatabase.java b/examples_java/src/collections/ship/marshal/SampleDatabase.java
new file mode 100644
index 0000000..53df679
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/SampleDatabase.java
@@ -0,0 +1,260 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+
+import com.sleepycat.bind.serial.ClassCatalog;
+import com.sleepycat.bind.serial.StoredClassCatalog;
+import com.sleepycat.bind.serial.TupleSerialKeyCreator;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+import com.sleepycat.db.Database;
+import com.sleepycat.db.DatabaseConfig;
+import com.sleepycat.db.DatabaseException;
+import com.sleepycat.db.DatabaseType;
+import com.sleepycat.db.Environment;
+import com.sleepycat.db.EnvironmentConfig;
+import com.sleepycat.db.ForeignKeyDeleteAction;
+import com.sleepycat.db.SecondaryConfig;
+import com.sleepycat.db.SecondaryDatabase;
+
+/**
+ * SampleDatabase defines the storage containers, indices and foreign keys
+ * for the sample database.
+ *
+ * @author Mark Hayes
+ */
+public class SampleDatabase {
+
+    private static final String CLASS_CATALOG = "java_class_catalog";
+    private static final String SUPPLIER_STORE = "supplier_store";
+    private static final String PART_STORE = "part_store";
+    private static final String SHIPMENT_STORE = "shipment_store";
+    private static final String SHIPMENT_PART_INDEX = "shipment_part_index";
+    private static final String SHIPMENT_SUPPLIER_INDEX =
+	"shipment_supplier_index";
+    private static final String SUPPLIER_CITY_INDEX = "supplier_city_index";
+
+    private Environment env;
+    private Database partDb;
+    private Database supplierDb;
+    private Database shipmentDb;
+    private SecondaryDatabase supplierByCityDb;
+    private SecondaryDatabase shipmentByPartDb;
+    private SecondaryDatabase shipmentBySupplierDb;
+    private StoredClassCatalog javaCatalog;
+
+    /**
+     * Open all storage containers, indices, and catalogs.
+     */
+    public SampleDatabase(String homeDirectory)
+        throws DatabaseException, FileNotFoundException {
+
+        // Open the Berkeley DB environment in transactional mode.
+        //
+        System.out.println("Opening environment in: " + homeDirectory);
+        EnvironmentConfig envConfig = new EnvironmentConfig();
+        envConfig.setTransactional(true);
+        envConfig.setAllowCreate(true);
+        envConfig.setInitializeCache(true);
+        envConfig.setInitializeLocking(true);
+        env = new Environment(new File(homeDirectory), envConfig);
+
+        // Set the Berkeley DB config for opening all stores.
+        //
+        DatabaseConfig dbConfig = new DatabaseConfig();
+        dbConfig.setTransactional(true);
+        dbConfig.setAllowCreate(true);
+        dbConfig.setType(DatabaseType.BTREE);
+
+        // Create the Serial class catalog.  This holds the serialized class
+        // format for all database records of serial format.
+        //
+        Database catalogDb = env.openDatabase(null, CLASS_CATALOG, null,
+                                              dbConfig);
+        javaCatalog = new StoredClassCatalog(catalogDb);
+
+        // Open the Berkeley DB database for the part, supplier and shipment
+        // stores.  The stores are opened with no duplicate keys allowed.
+        //
+        partDb = env.openDatabase(null, PART_STORE, null, dbConfig);
+
+        supplierDb = env.openDatabase(null, SUPPLIER_STORE, null, dbConfig);
+
+        shipmentDb = env.openDatabase(null, SHIPMENT_STORE, null, dbConfig);
+
+        // Open the SecondaryDatabase for the city index of the supplier store,
+        // and for the part and supplier indices of the shipment store.
+        // Duplicate keys are allowed since more than one supplier may be in
+        // the same city, and more than one shipment may exist for the same
+        // supplier or part.  A foreign key constraint is defined for the
+        // supplier and part indices to ensure that a shipment only refers to
+        // existing part and supplier keys.  The CASCADE delete action means
+        // that shipments will be deleted if their associated part or supplier
+        // is deleted.
+        //
+        SecondaryConfig secConfig = new SecondaryConfig();
+        secConfig.setTransactional(true);
+        secConfig.setAllowCreate(true);
+        secConfig.setType(DatabaseType.BTREE);
+        secConfig.setSortedDuplicates(true);
+
+        secConfig.setKeyCreator(new MarshalledKeyCreator(javaCatalog,
+                                                         Supplier.class,
+                                                         Supplier.CITY_KEY));
+        supplierByCityDb = env.openSecondaryDatabase(null, SUPPLIER_CITY_INDEX,
+                                                     null, supplierDb,
+                                                     secConfig);
+
+        secConfig.setForeignKeyDatabase(partDb);
+        secConfig.setForeignKeyDeleteAction(ForeignKeyDeleteAction.CASCADE);
+        secConfig.setKeyCreator(new MarshalledKeyCreator(javaCatalog,
+                                                         Shipment.class,
+                                                         Shipment.PART_KEY));
+        shipmentByPartDb = env.openSecondaryDatabase(null, SHIPMENT_PART_INDEX,
+                                                     null, shipmentDb,
+                                                     secConfig);
+
+        secConfig.setForeignKeyDatabase(supplierDb);
+        secConfig.setForeignKeyDeleteAction(ForeignKeyDeleteAction.CASCADE);
+        secConfig.setKeyCreator(new MarshalledKeyCreator(javaCatalog,
+                                                         Shipment.class,
+                                                     Shipment.SUPPLIER_KEY));
+        shipmentBySupplierDb = env.openSecondaryDatabase(null,
+                                                     SHIPMENT_SUPPLIER_INDEX,
+                                                     null, shipmentDb,
+                                                     secConfig);
+    }
+
+    /**
+     * Return the storage environment for the database.
+     */
+    public final Environment getEnvironment() {
+
+        return env;
+    }
+
+    /**
+     * Return the class catalog.
+     */
+    public final StoredClassCatalog getClassCatalog() {
+
+        return javaCatalog;
+    }
+
+    /**
+     * Return the part storage container.
+     */
+    public final Database getPartDatabase() {
+
+        return partDb;
+    }
+
+    /**
+     * Return the supplier storage container.
+     */
+    public final Database getSupplierDatabase() {
+
+        return supplierDb;
+    }
+
+    /**
+     * Return the shipment storage container.
+     */
+    public final Database getShipmentDatabase() {
+
+        return shipmentDb;
+    }
+
+    /**
+     * Return the shipment-by-part index.
+     */
+    public final SecondaryDatabase getShipmentByPartDatabase() {
+
+        return shipmentByPartDb;
+    }
+
+    /**
+     * Return the shipment-by-supplier index.
+     */
+    public final SecondaryDatabase getShipmentBySupplierDatabase() {
+
+        return shipmentBySupplierDb;
+    }
+
+    /**
+     * Return the supplier-by-city index.
+     */
+    public final SecondaryDatabase getSupplierByCityDatabase() {
+
+        return supplierByCityDb;
+    }
+
+    /**
+     * Close all stores (closing a store automatically closes its indices).
+     */
+    public void close()
+        throws DatabaseException {
+
+        // Close secondary databases, then primary databases.
+        supplierByCityDb.close();
+        shipmentByPartDb.close();
+        shipmentBySupplierDb.close();
+        partDb.close();
+        supplierDb.close();
+        shipmentDb.close();
+        // And don't forget to close the catalog and the environment.
+        javaCatalog.close();
+        env.close();
+    }
+
+    /**
+     * The SecondaryKeyCreator for MarshalledEnt objects.  This is an
+     * extension of the abstract class TupleSerialKeyCreator, which implements
+     * SecondaryKeyCreator for the case where the data keys are of the format
+     * TupleFormat and the data values are of the format SerialFormat.
+     */
+    private static class MarshalledKeyCreator
+        extends TupleSerialKeyCreator {
+
+        private String keyName;
+
+        /**
+         * Construct the key creator.
+         * @param catalog is the class catalog.
+         * @param valueClass is the supplier value class.
+         * @param keyName is the key name passed to the marshalling methods.
+         */
+        private MarshalledKeyCreator(ClassCatalog catalog,
+                                     Class valueClass,
+                                     String keyName) {
+
+            super(catalog, valueClass);
+            this.keyName = keyName;
+        }
+
+        /**
+         * Extract the city key from a supplier key/value pair.  The city key
+         * is stored in the supplier value, so the supplier key is not used.
+         */
+        public boolean createSecondaryKey(TupleInput primaryKeyInput,
+                                          Object valueInput,
+                                          TupleOutput indexKeyOutput) {
+
+            // the primary key is unmarshalled before marshalling the index
+            // key, to account for cases where the index key is composed of
+            // data elements from the primary key
+            MarshalledEnt entity = (MarshalledEnt) valueInput;
+            entity.unmarshalPrimaryKey(primaryKeyInput);
+            return entity.marshalSecondaryKey(keyName, indexKeyOutput);
+        }
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/SampleViews.java b/examples_java/src/collections/ship/marshal/SampleViews.java
new file mode 100644
index 0000000..91310e4
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/SampleViews.java
@@ -0,0 +1,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;
+        }
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/Shipment.java b/examples_java/src/collections/ship/marshal/Shipment.java
new file mode 100644
index 0000000..bbc2ccb
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/Shipment.java
@@ -0,0 +1,113 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.Serializable;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A Shipment represents the combined key/data pair for a shipment entity.
+ *
+ * <p> In this sample, Shipment is bound to the stored key/data entry by
+ * implementing the MarshalledEnt interface, which is called by {@link
+ * SampleViews.MarshalledEntityBinding}. </p>
+ *
+ * <p> The binding is "tricky" in that it uses this class for both the stored
+ * data entry and the combined entity object.  To do this, the key field(s) are
+ * transient and are set by the binding after the data object has been
+ * deserialized. This avoids the use of a ShipmentData class completely. </p>
+ *
+ * <p> Since this class is used directly for data storage, it must be
+ * Serializable. </p>
+ *
+ * @author Mark Hayes
+ */
+public class Shipment implements Serializable, MarshalledEnt {
+
+    static final String PART_KEY = "part";
+    static final String SUPPLIER_KEY = "supplier";
+
+    private transient String partNumber;
+    private transient String supplierNumber;
+    private int quantity;
+
+    public Shipment(String partNumber, String supplierNumber, int quantity) {
+
+        this.partNumber = partNumber;
+        this.supplierNumber = supplierNumber;
+        this.quantity = quantity;
+    }
+
+    /**
+     * Set the transient key fields after deserializing.  This method is only
+     * called by data bindings.
+     */
+    void setKey(String partNumber, String supplierNumber) {
+
+        this.partNumber = partNumber;
+        this.supplierNumber = supplierNumber;
+    }
+
+    public final String getPartNumber() {
+
+        return partNumber;
+    }
+
+    public final String getSupplierNumber() {
+
+        return supplierNumber;
+    }
+
+    public final int getQuantity() {
+
+        return quantity;
+    }
+
+    public String toString() {
+
+        return "[Shipment: part=" + partNumber +
+                " supplier=" + supplierNumber +
+                " quantity=" + quantity + ']';
+    }
+
+    // --- MarshalledEnt implementation ---
+
+    Shipment() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalPrimaryKey(TupleInput keyInput) {
+
+        this.partNumber = keyInput.readString();
+        this.supplierNumber = keyInput.readString();
+    }
+
+    public void marshalPrimaryKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.partNumber);
+        keyOutput.writeString(this.supplierNumber);
+    }
+
+    public boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput) {
+
+        if (keyName.equals(PART_KEY)) {
+            keyOutput.writeString(this.partNumber);
+            return true;
+        } else if (keyName.equals(SUPPLIER_KEY)) {
+            keyOutput.writeString(this.supplierNumber);
+            return true;
+        } else {
+            throw new UnsupportedOperationException(keyName);
+        }
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/ShipmentKey.java b/examples_java/src/collections/ship/marshal/ShipmentKey.java
new file mode 100644
index 0000000..a066822
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/ShipmentKey.java
@@ -0,0 +1,69 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A ShipmentKey serves as the key in the key/data pair for a shipment entity.
+ *
+ * <p> In this sample, ShipmentKey is bound to the stored key tuple entry by
+ * implementing the MarshalledKey interface, which is called by {@link
+ * SampleViews.MarshalledKeyBinding}. </p>
+ *
+ * @author Mark Hayes
+ */
+public class ShipmentKey implements MarshalledKey {
+
+    private String partNumber;
+    private String supplierNumber;
+
+    public ShipmentKey(String partNumber, String supplierNumber) {
+
+        this.partNumber = partNumber;
+        this.supplierNumber = supplierNumber;
+    }
+
+    public final String getPartNumber() {
+
+        return partNumber;
+    }
+
+    public final String getSupplierNumber() {
+
+        return supplierNumber;
+    }
+
+    public String toString() {
+
+        return "[ShipmentKey: supplier=" + supplierNumber +
+                " part=" + partNumber + ']';
+    }
+
+    // --- MarshalledKey implementation ---
+
+    ShipmentKey() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalKey(TupleInput keyInput) {
+
+        this.partNumber = keyInput.readString();
+        this.supplierNumber = keyInput.readString();
+    }
+
+    public void marshalKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.partNumber);
+        keyOutput.writeString(this.supplierNumber);
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/Supplier.java b/examples_java/src/collections/ship/marshal/Supplier.java
new file mode 100644
index 0000000..43d97c0
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/Supplier.java
@@ -0,0 +1,118 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.Serializable;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A Supplier represents the combined key/data pair for a supplier entity.
+ *
+ * <p> In this sample, Supplier is bound to the stored key/data entry by
+ * implementing the MarshalledEnt interface, which is called by {@link
+ * SampleViews.MarshalledEntityBinding}. </p>
+ *
+ * <p> The binding is "tricky" in that it uses this class for both the stored
+ * data entry and the combined entity object.  To do this, the key field(s) are
+ * transient and are set by the binding after the data object has been
+ * deserialized. This avoids the use of a SupplierData class completely. </p>
+ *
+ * <p> Since this class is used directly for data storage, it must be
+ * Serializable. </p>
+ *
+ * @author Mark Hayes
+ */
+public class Supplier implements Serializable, MarshalledEnt {
+
+    static final String CITY_KEY = "city";
+
+    private transient String number;
+    private String name;
+    private int status;
+    private String city;
+
+    public Supplier(String number, String name, int status, String city) {
+
+        this.number = number;
+        this.name = name;
+        this.status = status;
+        this.city = city;
+    }
+
+    /**
+     * Set the transient key fields after deserializing.  This method is only
+     * called by data bindings.
+     */
+    void setKey(String number) {
+
+        this.number = number;
+    }
+
+    public final String getNumber() {
+
+        return number;
+    }
+
+    public final String getName() {
+
+        return name;
+    }
+
+    public final int getStatus() {
+
+        return status;
+    }
+
+    public final String getCity() {
+
+        return city;
+    }
+
+    public String toString() {
+
+        return "[Supplier: number=" + number +
+               " name=" + name +
+               " status=" + status +
+               " city=" + city + ']';
+    }
+
+    // --- MarshalledEnt implementation ---
+
+    Supplier() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalPrimaryKey(TupleInput keyInput) {
+
+        this.number = keyInput.readString();
+    }
+
+    public void marshalPrimaryKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.number);
+    }
+
+    public boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput) {
+
+        if (keyName.equals(CITY_KEY)) {
+            if (this.city != null) {
+                keyOutput.writeString(this.city);
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            throw new UnsupportedOperationException(keyName);
+        }
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/SupplierKey.java b/examples_java/src/collections/ship/marshal/SupplierKey.java
new file mode 100644
index 0000000..d8ab019
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/SupplierKey.java
@@ -0,0 +1,59 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * A SupplierKey serves as the key in the key/data pair for a supplier entity.
+ *
+ * <p> In this sample, SupplierKey is bound to the stored key tuple entry by
+ * implementing the MarshalledKey interface, which is called by {@link
+ * SampleViews.MarshalledKeyBinding}. </p>
+ *
+ * @author Mark Hayes
+ */
+public class SupplierKey implements MarshalledKey {
+
+    private String number;
+
+    public SupplierKey(String number) {
+
+        this.number = number;
+    }
+
+    public final String getNumber() {
+
+        return number;
+    }
+
+    public String toString() {
+
+        return "[SupplierKey: number=" + number + ']';
+    }
+
+    // --- MarshalledKey implementation ---
+
+    SupplierKey() {
+
+        // A no-argument constructor is necessary only to allow the binding to
+        // instantiate objects of this class.
+    }
+
+    public void unmarshalKey(TupleInput keyInput) {
+
+        this.number = keyInput.readString();
+    }
+
+    public void marshalKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(this.number);
+    }
+}
diff --git a/examples_java/src/collections/ship/marshal/Weight.java b/examples_java/src/collections/ship/marshal/Weight.java
new file mode 100644
index 0000000..608629d
--- /dev/null
+++ b/examples_java/src/collections/ship/marshal/Weight.java
@@ -0,0 +1,49 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package collections.ship.marshal;
+
+import java.io.Serializable;
+
+/**
+ * Weight represents a weight amount and unit of measure.
+ *
+ * <p> In this sample, Weight is embedded in part data values which are stored
+ * as Java serialized objects; therefore Weight must be Serializable. </p>
+ *
+ * @author Mark Hayes
+ */
+public class Weight implements Serializable {
+
+    public final static String GRAMS = "grams";
+    public final static String OUNCES = "ounces";
+
+    private double amount;
+    private String units;
+
+    public Weight(double amount, String units) {
+
+        this.amount = amount;
+        this.units = units;
+    }
+
+    public final double getAmount() {
+
+        return amount;
+    }
+
+    public final String getUnits() {
+
+        return units;
+    }
+
+    public String toString() {
+
+        return "[" + amount + ' ' + units + ']';
+    }
+}