The Castor persistence engine handles object persistence, object caching, transaction concurrency and locking.
See: Description
Interface Summary | |
---|---|
DepositBox | DepositBox is an interface for {@link ClassMolder} to access the dirty checking cache of an object. |
Lazy | Lazy is a place holder interface to indicate that a data object or a Collection in a data object is an Lazy instance. |
TxSynchronizable | This interface offers some callback hooks for several different stages during a transaction. |
XAResourceSource | A data source that wishes to particiate as an XA resource implements this interface. |
Class Summary | |
---|---|
ClassMolder | ClassMolder is a binder for one type of data object and its {@link Persistence}. |
CollectionProxy | This class is a proxy for different types of Colleciton and Maps. |
DatingService | DataService is a helper class for constructing ClassMolders and pairing up ClassMolders which depends and extends the other. |
FieldMolder | FieldMolder represents a field of a data object class. |
FieldMolder.CollectionInfo | |
KeyGeneratorFactoryRegistry | Registry for {@link KeyGeneratorFactory} implementations obtained from the Castor properties file and used by the JDO mapping configuration file. |
LockEngine | LockEngine is a gateway for all the ClassMolders of a persistence storage. |
LRU |
Base interface for all least-recently-used cache. |
LRU.CountLimited | CountLimited is a count limted least-recently-used Map. |
LRU.NoCache | NoCache is a Map which dispose all object right the way. |
LRU.TimeLimited | TimeLimited is a time limted least-recently-used Map. |
LRU.Unlimited | UnLimited is Map which implements the {@link LRU} interface. |
ObjectDeletedWaitingForLockException | Thrown to indicate that a lock attempt has failed due to object being deleted by a concurrent transaction. |
ObjectLock | Read/write locks and lock synchronization on an object. |
ObjectLock.LinkedTx | Object uses to hold a linked list of transactions holding write locks or waiting for a read/write lock. |
OID | Object identifier. |
OutputLogInterceptor | A simple log interceptor that reports all messages to a writer or an output stream. |
PersistenceEngineFactory | Factory for constructing new persistence engines. |
PersistenceFactoryRegistry | Registry for {@link PersistenceFactory} implementations obtained from the Castor properties file and used by the JDO database configuration file. |
PersistenceInfo | Redistribution and use of this software and associated documentation ("Software"), with or without modification, are permitted provided that the following conditions are met: 1. |
PersistenceInfoGroup | Redistribution and use of this software and associated documentation ("Software"), with or without modification, are permitted provided that the following conditions are met: 1. |
QueryResults | The result of a query in the context of a transaction. |
RelationCollection | RelationCollection implements {@link java.util.Collection} It is a lazy Colllection. |
SQLRelationLoader | SQLRelationLoader is a quick hack for creating and removing relation from a many-to-many relation database from ClassMolder. |
TransactionContext | A transaction context is required in order to perform operations against the database. |
TransactionContext.ObjectEntry | A transaction records all objects accessed during the lifetime of the transaction in this record (queries and created). |
XAResourceImpl | An {@link XAResource} implementation for an {@link XAResourceSource}. |
The Castor persistence engine handles object persistence, object caching, transaction concurrency and locking. This package is not used directly by application developer, and includes the interfaces, implementations and persistence exceptions.
The persistence engine API is used by the application APIs (JDO, CMP, DAX) to implement caching, queries, transactions and concurrency, etc. This layer is shared by all persistence engine and exposes a unified interface for use as a persistence engine for EJB CMP.
An application API will use a {@link org.exolab.castor.persist.TransactionContext} in order to perform operations. All operations against the persistence engine are transactional. The persistence engine is obtained through the {@link org.exolab.castor.persist.PersistenceEngineFactory} class which returns a {@link org.exolab.castor.persist.LockEngine}. The factory requires a factory of persistence SPIs (see SPI.
{@link org.exolab.castor.persist.LockEngine} implements a persistence engine that caches objects in memory for performance, and eliminates the number of persistent storage operations. In order to speed up interaction between the engines and the object, {@link org.exolab.castor.persist.ClassMolder} is constructed to represent a flat view of the object graph that is efficient to process.
If the application API supports enlistment as an XA resource, it will use {@link org.exolab.castor.persist.XAResourceImpl} and implement {@link org.exolab.castor.persist.XAResourceSource} for automatic enlistment/delistment with a transaction context.
The reminder of this package are persistence exceptions and concurrency engine implementation.