Package net.ontopia.persistence.proxy

package net.ontopia.persistence.proxy

An object-relational mapping framework.

Class	Description
AbstractFieldInfo	INTERNAL: An abstract field info class containing the common behaviour for FieldInfoIFs.
AbstractLocalCache	INTERNAL: A transactional storage cache implementation.
AbstractROPersistent	INTERNAL: An abstract PersistentIF implementation that handles most of the machinery needed to implement persistent objects.
AbstractRWPersistent	INTERNAL: An abstract PersistentIF implementation that handles most of the machinery needed to implement persistent objects.
AbstractTransaction	INTERNAL: The default proxy transaction implementation.
AccessRegistrarIF	INTERNAL: Interface for receiving notification when data is being read from database storage.
AggregateFieldInfo	INTERNAL: A field that references an aggregate class.
AtomicIdentity	INTERNAL: Class used for representing data store object identities with only a single key.
CacheEntry	INTERNAL: Class used by storage caches to hold field values for a single object.
CacheIF<K,V>	INTERNAL: Simple interface used by innermost caches.
CacheMetricsIF
CachesIF	INTERNAL:
ClassAccessIF	INTERNAL: Interface for accessing class instances in the database.
ClassDescriptor	INTERNAL: Class used for holding object relational mapping class declarations.
ClassInfo	INTERNAL: A class descriptor-like class that is used by the RDBMS proxy implementation to access the information it needs about the object relational class descriptor in an optimized manner.
ClassInfoIF	INTERNAL: A interface for class descriptor-like object types that is used by the proxy implementation to access the information it needs about the object relational class descriptor in an optimized manner.
ClusteredCache<K,V>	INTERNAL: CacheIF implementation that wraps a Map and notified the cluster about removals.
ClusterIF	INTERNAL: Cluster implementation interface.
ConnectionFactoryIF	INTERNAL: An interface for creating/requesting new JDBC connection object.
ContentInputStream	INTERNAL: InputStream that knows its length.
ContentReader	INTERNAL: Reader that knows its length.
DataSourceConnectionFactory	INTERNAL: A ConnectionFactoryIF backed by a DataSource.
DBCPDataSource	INTERNAL: A datasource wrapping the DBCP2 connection pooling.
DefaultCache<K,V>	INTERNAL: CacheIF implementation that wraps a Map.
DefaultCaches	INTERNAL: Default caches.
DefaultFieldHandler	INTERNAL: The default field handler implementation that is able to read values from result sets and bind values in prepared statements without any particular knowledge about fields.
DriverDataSource	INTERNAL: A datasource creating connections from a DriverManagerConnectionFactory.
EvictableIF<K,E>	INTERNAL: Simple interface used by helper objects for invalidation purposes.
FieldAccessIF	INTERNAL: Interface for reading and updating object field values.
FieldDescriptor	INTERNAL: Class used for holding object relational mapping field declarations.
FieldHandlerIF	INTERNAL: Interface for use by classes that retrieve field values from result sets and bind values in prepared statements.
FieldInfoIF	INTERNAL: A field descriptor-like class that is used by the RDBMS proxy implementation to access the information it needs about the object relational field descriptor in an optimized manner.
FieldUtils	INTERNAL: Class containing utility methods for processing descriptor information.
FlushableIF	INTERNAL: Interface implemented by data repository accessors that needs to be informed when changes to the repository needs to be performed.
HighLowKeyGenerator	INTERNAL: A key generator using the HIGH/LOW key generator algorithm.
Identity	INTERNAL: Class used for representing data store object identities with more than a single key.
IdentityCollectionWrapper<E>	INTERNAL: A set implementation that wraps an identity collection and presents the underlying collection as if it had PersistentIF instances inside.
IdentityFieldInfo	INTERNAL: A field that represents the identity of instances of a class.
IdentityIF	INTERNAL: Interface used to represent data store object identity.
IdentityNotFoundException	INTERNAL: Thrown when an object was not found in the database.
IndicatorFieldHandler	INTERNAL: The indicator field handler implementation that is able to...
InstrumentedDataSourceIF	INTERNAL: Shared metrics across Datasources.
JGroupsCaches	INTERNAL: Caches used by JGroups cluster.
JGroupsCluster	INTERNAL: Class that represents a cluster of OKS instances.
JGroupsEvent	INTERNAL:
JNDIDataSource	INTERNAL: A JNDI datasource wrapper to allow metrics.
KeyGeneratorIF	INTERNAL: Interface for generating new object identities.
LongIdentity	INTERNAL: Class used for representing data store object identities with only a single long key.
ObjectAccessIF	INTERNAL: A object access implementation for manipulation of identifiable objects.
ObjectRelationalMapping	INTERNAL: The generic object relational mapping definition class.
ObjectRelationalMappingIF	INTERNAL: An object relational mapping wrapper class used by the RDBMS proxy implementation.
ObjectStates	INTERNAL: A data structure that keeps track of the objects that has been touched within the transaction boundaries.
OnDemandValue	INTERNAL:
PersistenceException	INTERNAL: Thrown when persistence related problems occur.
PersistenceRuntimeException	INTERNAL: Thrown when persistence related problems occur.
PersistentIF	INTERNAL: Interface implemented by all data objects used by the proxy framework.
PersistentIterator<E>	INTERNAL: Iterator that iterates over an iterator of IdentityIF values and looks up the objects in the transaction.
PersistentObjectAccess	INTERNAL: Object access for objects implementing the PersistentIF interface.
PrimitiveFieldInfo	INTERNAL: A field that references a primitive value class.
QueryCache<K,E>	INTERNAL: A storage access implementation accessing relational databases using JDBC.
QueryCollection<E>	INTERNAL: Immutable Collection implementation that delegates its data retrieval to QueryIFs.
QueryDeclarations	INTERNAL: Class that is able to read named query definitions from an XML representation.
QueryDescriptor	INTERNAL: Class used for loading and managing SQL query declarations.
QueryIF	INTERNAL: Interface for representing queries.
QueryResultIF	INTERNAL: Interface for representing two-dimensional (or potentially even N-dimensional) query results.
QueryResultIterator<E>	INTERNAL: Interator wrapper class for QueryResultIFs.
RDBMSAccess	INTERNAL: A storage access implementation accessing relational databases using JDBC.
RDBMSMapping	INTERNAL: An object relational mapping wrapper class used by the RDBMS proxy implementation.
RDBMSMetricsIF	PUBLIC: Provides metrics regarding RDBMS proxy connections.
RDBMSStorage	INTERNAL: A storage definition implementation for relational databases.
ReadOnlySet<E>	INTERNAL: A set implementation that track the changes performed on it.
ReadOnlyTransactionException	INTERNAL: Thrown when modifications are attempted on a read-only transaction.
ReferenceFieldInfo	INTERNAL: A field that references objects.
ROLocalCache	INTERNAL: A transactional read-only storage cache implementation.
ROTransaction	INTERNAL: The read-only proxy transaction implementation.
RWLocalCache	INTERNAL: A transactional storage cache implementation.
RWTransaction	INTERNAL: The read-write proxy transaction implementation.
SharedCache	INTERNAL: A shared storage cache implementation.
SQLBatchManyToManyReference	INTERNAL: Class that performs the task of accessing and manipulating M:M reference fields in the database.
SQLBatchObjectAccess	INTERNAL: Class that performs the task of creating new objects in the database.
SQLBatchOneToManyAggregate	INTERNAL: Class that performs the task of accessing and manipulating 1:M aggregate fields in the database.
SQLBatchOneToManyReference	INTERNAL: Class that performs the task of accessing and manipulating 1:M reference fields in the database.
SQLBatchOneToOne	INTERNAL: Class that performs the task of accessing and manipulating 1:1 fields in the database.
SQLCollectionAccess	INTERNAL: Class that performs the task of accessing and manipulating "collection" type instances in the database.
SQLGenerator	INTERNAL: Utility class that can generate SQL statements.
SQLManyToManyReference	INTERNAL: Class that performs the task of accessing and manipulating M:M reference fields in the database.
SQLObjectAccess	INTERNAL: Class that performs the task of accessing and manipulating "identifiable object type" instances in the database.
SQLOneToManyAggregate	INTERNAL: Class that performs the task of accessing and manipulating 1:M aggregate fields in the database.
SQLOneToManyReference	INTERNAL: Class that performs the task of accessing and manipulating 1:M reference fields in the database.
SQLOneToOne	INTERNAL: Class that performs the task of accessing and manipulating 1:1 fields in the database.
SQLReader	INTERNAL: Reader that knows its length.
SQLTypes	INTERNAL: Utility class for handling access to columns by proper SQL type.
StatisticsCache	INTERNAL: A transactional storage cache implementation.
StorageAccessIF	INTERNAL: Interface that encapsulates the access to the actual data repository.
StorageCacheIF	INTERNAL: Interface used by the transaction to get hold of objects and object field values.
StorageIF	INTERNAL: Interface for accessing storage definitions.
TicketIF	INTERNAL: A simple ticket interface.
TrackableCollectionIF<E>	INTERNAL: Interface used by Collection implementations that track the changes performed on them.
TrackableLazySet<E>	INTERNAL: A set implementation that track the changes performed on it.
TrackableSet<E>	INTERNAL: A set implementation that track the changes performed on it.
TransactionalLookupIndexIF<K,E>	INTERNAL: Interface shared by the lookup indexes that look up data in the backend storage.
TransactionalLRULookupIndex	INTERNAL:
TransactionalSoftHashMapIndex<K,V>	INTERNAL:
TransactionEventListenerIF	INTERNAL: Interface for receiving notification when transaction life-cycle events occur.
TransactionIF	INTERNAL: Interface that manages object transactions using the proxy framework.
TransactionNotActiveException	INTERNAL: Thrown when persistence related problems occur.
WrappedIdentity	INTERNAL: Class used for wrapping other identities.