This chapter provides information about concurrency, version numbers, and Java-supplied persistence-capable classes.

This chapter discusses the following topics:

Obtaining PSE/PSE Pro Version Information

% osjversion

%

This command is useful when you want to ensure that you have the right version in your path.

You can also run the unzip -z command against any PSE/PSE Pro .zip file. Doing so allows you to see what version of PSE/PSE Pro the zip file contains. For example:

% unzip -z pro.zip

Archive: pro.zip ObjectStore PSE Pro for Java Release 1.1, 97-04-19 12:22:16 on buildhost,

Copyright 1996, 1997 Object Design, Inc. All rights reserved.

%

import COM.odi.ObjectStore;
class OSVersion {
      public static void main (String[] args) {
            ObjectStore.initialize(null,null);
            System.out.println(ObjectStore.releaseName());
      }
}

Description of Java-Supplied Persistence-Capable Classes

• java.lang.String
  
• The wrapper classes:
  
  • java.lang.Boolean
    
    
  • java.lang.Byte
    
    
  • java.lang.Character
    
    
  • java.lang.Double
    
    
  • java.lang.Float
    
    
  • java.lang.Integer
    
    
  • java.lang.Long
    
    
  • java.lang.Short
    
• Arrays of any type
  

boolean comparePersistIntegers(Integer x, Integer y) {
      return (x == y);
}

boolean comparePersistIntegers(Integer x, Integer y) {
      return x.equals(y);
}

Can Other Java-Supplied Classes Be Persistence-Capable?

Native methods

Classes that hold state

Postprocessing

osjcfp -dest \osjcfpout -modifyjava java.lang.StringBuffer

Performance drawbacks

How much slowdown is hard to determine. It depends on the details of the method. Even parts of your program that never handle persistence are affected by these extra instructions. This also applies to indirect uses of the class, for example, if StringBuffer is used heavily in some Java library that you are using, such as a user interface or network library.

Library version problems

Renaming the class

This avoids the problem and is generally safer. However, you might need the persistence-capable class to have the original class name. For example, suppose you have a library that has a method that takes an argument of type java.lang.Stringbuffer. You want to pass in a persistence-capable object. You cannot rename the class because the argument type would not match.

java.util.Hashtable

Serializing Persistent Objects

PSE/PSE Pro uses this constructor to deserialize instances of a persistence-capable class that you define. For this to work, the definition of your persistence-capable class must implement the java.io.Serializable interface. The Persistent class does not implement the Serializable interface because doing so would be incompatible with earlier versions of the JDK. COM.odi.Persistent will implement java.io.Serializable in a future release.

During serialization, none of the transient fields in the Persistent class need to be written out. During deserialization, PSE/PSE Pro uses the no-arguments constructor to correctly initialize these transient fields.

Before serializing an object, an application must always invoke Persistent.deepFetch() on the object to be serialized. The deepFetch() method ensures that the contents of all components of the object are accessible. This must be the case for an application to serialize an object.

Example

public
class SerializationExample {
public static void main(String argv[])
      throws java.lang.ClassNotFoundException, java.io.IOException,
      java.io.FileNotFoundException {
      String dbName = argv[0];
      ObjectStore.initialize(null, null);
      Database db = Database.create(dbname, 
            ObjectStore.ALL_READ | ObjectStore.ALL_WRITE);
      /* Create a database with a list in it. */
      Transaction tr = Transaction.begin(ObjectStore.UPDATE);
      List curr = new List("1", null);
      db.createRoot("list", curr);
      for (int i=2; i < 5; i++) {
            curr.next = new List(""+i, null);
            curr = curr.next;
       }
      tr.commit();
      /* Illustrate use of serialization in this example. */
      tr = Transaction.begin(ObjectStore.UPDATE);
      List head = (List)db.getRoot("list");
      /* fetch the entire list prior to serializing it. */
      Persistent.deepFetch(head);
      FileOutputStream f = new FileOutputStream("tmp");
      new ObjectOutputStream(f);  ->  new  ObjectOutputStream(f);
      os.writeObject(head);
      FileInputStream in = new FileInputStream("tmp");
      ObjectInputStream is = new ObjectInputStream(in);
      /* list2 is effectively a copy of the list denoted by head. */
      List list2 = (List)is.readObject();
      ...
      }
      tr.commit();
      }
}
public class List implements java.io.Serializable {
      public Object value;
      public List next;
      List(Object value, List next) {
            this.value = value;
            this.next = next;
      }
      ...
}

Updated: 05/13/97 12:18:48