org.nakedobjects.object
Class TransientObjectStore

java.lang.Object
  org.nakedobjects.object.AbstractNakedObjectStore
      org.nakedobjects.object.TransientObjectStore

All Implemented Interfaces:

DebugInfo, NakedObjectStore

public class TransientObjectStore

extends AbstractNakedObjectStore

Constructor Summary

TransientObjectStore()

Method Summary

void	abortTransaction()
void	addElement(NakedCollection collection, NakedObject element)
boolean	containsElement(NakedCollection collection, NakedObject element)
void	destroyObject(NakedObject object) Removes the specified object from the object store.
void	endTransaction()
NakedObject	finderObject(NakedClass type)
java.util.Vector	getNextElements(NakedCollection collection, NakedObject fromObject, int size) Retrieve the next set (the number specified by count) of objects for the specified collection starting from, but not including, the specified object.
java.util.Vector	getNextInstances(NakedObject pattern, NakedObject fromObject, int size) Gets the next page of instances.
NakedObject	getObject(java.lang.Object oid) Retrieves the object identified by the specified OID from the object store.
java.util.Vector	getPreviousElements(NakedCollection collection, NakedObject toObject, int size) Retrieve the previous set (the number specified by count) of objects for the specified collection starting from the specified object.
java.util.Vector	getPreviousInstances(NakedObject pattern, NakedObject toObject, int size) Gets the previous page of instances.
boolean	hasInstances(NakedClass expressiveClass) Checks whether there are any instances of the specified type.
boolean	isFirstElement(NakedCollection collection, NakedObject element)
boolean	isFirstInstance(NakedObject pattern, NakedObject instance) Checks whether the specified instance is the first one instance in the set of all instances.
boolean	isLastElement(NakedCollection collection, NakedObject element)
boolean	isLastInstance(NakedObject pattern, NakedObject instance) Checks whether the specified instance is the last instance in the set of all instances.
void	makePersistent(NakedObject object) Makes a naked object persistent.
java.lang.String	name()
java.lang.Object	newOid()
int	numberOfElements(NakedCollection collection)
int	numberOfInstances(NakedObject pattern)
void	removeElement(NakedCollection collection, NakedObject element)
void	resolve(NakedObject object) Re-initialises the fields of an object.
void	save(NakedObject object) Persists the specified object's state.
long	serialNumber(java.lang.String id) Generates a unique serial number for the specified squence set.
void	startTransaction()

Methods inherited from class org.nakedobjects.object.AbstractNakedObjectStore

areObjectsDistributed, areObjectsProxied, broadcastAddUpdate, broadcastObjectUpdate, broadcastRemoveUpdate, classes, createInstance, getCachedObject, getDebugData, getDebugTitle, getLog, init, isLoaded, loaded, log, log, persistenceType, restart, setLog, setUpdateNotifier, shutdown, unloaded

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TransientObjectStore

public TransientObjectStore()

Method Detail

isFirstElement

public boolean isFirstElement(NakedCollection collection,
                              NakedObject element)
                       throws NonPersistentObjectException,
                              ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

isFirstInstance

public boolean isFirstInstance(NakedObject pattern,
                               NakedObject instance)
                        throws NonPersistentObjectException

Description copied from interface: NakedObjectStore

Checks whether the specified instance is the first one instance in the set of all instances. The object store should find the instances as specified in the getNextInstances method. It should then check the first instance to see if it is the same as the one specified in instance and return true if it is, or false if it isn't.

Throws:

NonPersistentObjectException

isLastElement

public boolean isLastElement(NakedCollection collection,
                             NakedObject element)
                      throws NonPersistentObjectException,
                             ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

isLastInstance

public boolean isLastInstance(NakedObject pattern,
                              NakedObject instance)
                       throws NonPersistentObjectException

Description copied from interface: NakedObjectStore

Checks whether the specified instance is the last instance in the set of all instances. The object store should find the instances as specified in the getPreviousInstances method. It should then check the last instance to see if it is the same as the one specified in instance and return true if it is, or false if it isn't.

Throws:

NonPersistentObjectException

getNextElements

public java.util.Vector getNextElements(NakedCollection collection,
                                        NakedObject fromObject,
                                        int size)
                                 throws ObjectNotFoundException,
                                        NonPersistentObjectException,
                                        ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieve the next set (the number specified by count) of objects for the specified collection starting from, but not including, the specified object. If fromObject is null then start from the first element. If the number of returned is less than the requested number then this set is the last set.

Throws:

ObjectNotFoundException

NonPersistentObjectException

ObjectStoreException

getNextInstances

public java.util.Vector getNextInstances(NakedObject pattern,
                                         NakedObject fromObject,
                                         int size)
                                  throws NonPersistentObjectException,
                                         ObjectNotFoundException

Description copied from interface: NakedObjectStore

Gets the next page of instances. The object store should create a vector and add to it those instances held by the persistence mechanism that:- 1) are of the type that the pattern object is; 2) have the same content as the pattern object where the pattern object has values or references specified, i.e. empty value objects and null references are to be ignored; 3) matches the fromObject object, or those that are found after it, unless fromObject is null in which case this last condition does not apply. The number of instances added to the vector should be limited to the number specified in count.

Throws:

NonPersistentObjectException

ObjectNotFoundException

getObject

public NakedObject getObject(java.lang.Object oid)
                      throws ObjectNotFoundException,
                             ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieves the object identified by the specified OID from the object store. The cache should be checked first and, if the object is cached, the cached version should be returned. It is important that if this method is called again, while the originally returned object is in working memory, then this method must return that same Java object. Assuming that the object is not cached then the data for the object should be retreived from the persistence mechanism and the object recreated (as describe previously). The specified OID should then be assigned to the recreated object by calling its setOID. Before returning the object its resolved flag should also be set by calling its setResolved method as well. If the persistence mechanism does not known of an object with the specified OID then a ObjectNotFoundException should be thrown. Note that the OID could be for an internal collection, and is therefore related to the parent object (using a CompositeOid). The elements for an internal collection are commonly stored as part of the parent object, so to get element the parent object needs to be retrieved first, and the internal collection can be got from that. Returns the stored NakedObject object that has the specified OID.

Parameters:

oid - org.nakedobjects.object.Oid

Returns:

org.nakedobjects.object.NakedObject

Throws:

ObjectNotFoundException - when no object corresponding to the oid can be found

ObjectStoreException

getPreviousElements

public java.util.Vector getPreviousElements(NakedCollection collection,
                                            NakedObject toObject,
                                            int size)
                                     throws ObjectNotFoundException,
                                            NonPersistentObjectException,
                                            ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieve the previous set (the number specified by count) of objects for the specified collection starting from the specified object. If fromObject is null then start from the first element. If the number of elements before toObject is less than the number of elements requested then return the required number of elements from the start of the collection.

Throws:

ObjectNotFoundException

NonPersistentObjectException

ObjectStoreException

getPreviousInstances

public java.util.Vector getPreviousInstances(NakedObject pattern,
                                             NakedObject toObject,
                                             int size)
                                      throws NonPersistentObjectException

Description copied from interface: NakedObjectStore

Gets the previous page of instances. This should be implemented as the getNextInstances method was, except the last instance in the vector should be the one specified in toObject. If, however, the toObject is null then the vector should contain the last count instances.

Throws:

NonPersistentObjectException

abortTransaction

public void abortTransaction()

addElement

public void addElement(NakedCollection collection,
                       NakedObject element)
                throws NonPersistentObjectException,
                       ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

containsElement

public boolean containsElement(NakedCollection collection,
                               NakedObject element)
                        throws NonPersistentObjectException,
                               ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

destroyObject

public void destroyObject(NakedObject object)
                   throws NonPersistentObjectException

Description copied from interface: NakedObjectStore

Removes the specified object from the object store. The specified object's data should be removed from the persistence mechanism and, if it is cached (which it probably is), removed from the cache also.

Throws:

NonPersistentObjectException

endTransaction

public void endTransaction()

finderObject

public NakedObject finderObject(NakedClass type)

hasInstances

public boolean hasInstances(NakedClass expressiveClass)

Description copied from interface: NakedObjectStore

Checks whether there are any instances of the specified type. The object store should look for instances of the type represented by type and return true if there are, or false if there are not.

makePersistent

public void makePersistent(NakedObject object)
                    throws ObjectStoreException

Description copied from interface: NakedObjectStore

Makes a naked object persistent. The specified object should be stored away via this object store's persistence mechanism, and have an new and unique OID assigned to it (by calling the object's setOid method). The object, should also be added to the cache as the object is implicitly 'in use'.

If the object has any associations then each of these, where they aren't already persistent, should also be made persistent by recursively calling this method.

If the object to be persisted is a collection, then each element of that collection, that is not already persistent, should be made persistent by recursively calling this method.

Throws:

ObjectStoreException

name

public java.lang.String name()

newOid

public java.lang.Object newOid()

numberOfElements

public int numberOfElements(NakedCollection collection)
                     throws NonPersistentObjectException,
                            ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

numberOfInstances

public int numberOfInstances(NakedObject pattern)
                      throws NonPersistentObjectException,
                             ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

removeElement

public void removeElement(NakedCollection collection,
                          NakedObject element)
                   throws NonPersistentObjectException,
                          ObjectStoreException

Throws:

NonPersistentObjectException

ObjectStoreException

resolve

public void resolve(NakedObject object)
             throws ObjectNotFoundException,
                    ObjectStoreException

Description copied from interface: NakedObjectStore

Re-initialises the fields of an object. This method should return immediately if the object's resolved flag (determined by calling isResolved on the object) is already set. If the object is unresolved then the object's missing data should be retreieved from the persistence mechanism and be used to set up the value objects and associations. The object should be set up in the same manner as in getObject above.

Throws:

ObjectNotFoundException

ObjectStoreException

save

public void save(NakedObject object)
          throws NonPersistentObjectException,
                 ObjectStoreException

Description copied from interface: NakedObjectStore

Persists the specified object's state. Essentially the data held by the persistence mechanism should be updated reflect the state of the specified objects. Once updated, the object store should issue a notification to all of the object's users via the UpdateNotifier object. This can be achieved simply, if extending the AbstractObjectStore by calling its broadcastObjectUpdate method.

Throws:

NonPersistentObjectException

ObjectStoreException

serialNumber

public long serialNumber(java.lang.String id)

Description copied from interface: NakedObjectStore

Generates a unique serial number for the specified squence set. Each set of serial numbers are a simple numerical sequence. Calling this method with a unused sequence name creates a new set.

startTransaction

public void startTransaction()