EntityManagerLite (Classy Tools Parent 1.2 API)

All Known Implementing Classes:

EntityManagerImpl
```
public interface EntityManagerLite
```
Interface used to interact with the persistence context and to create executable query objects. Only a subset of PersistenceUnitAdmin API 1.0 methods supported, except generic version selected over non-generic when applicable. In particular, LockMode is not supported.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clear()` Clear the persistence context, causing all managed entities to become detached.
`void`	`close()` DO NOT CALL close() as the container will do this automatically.
`boolean`	`contains(Object entity)` Check if the instance is a managed entity instance belonging to the current persistence context.
`javax.persistence.Query`	`createNamedQuery(String name)` Create an instance of Query for executing a named query (in the Java PersistenceUnitAdmin query language or in native SQL).
`<T> T`	`find(Class<T> entityClass, Object primaryKey)` Find by primary key.
`void`	`flush()` Synchronize the persistence context to the underlying database.
`Object`	`getDelegate()` Returns EntityManagerDelegate object which provides access to OrmLite DAOs.
`javax.persistence.FlushModeType`	`getFlushMode()` Get the flush mode that applies to all objects contained in the persistence context.
`<T> T`	`getReference(Class<T> entityClass, Object primaryKey)` Get an instance, whose state may be lazily fetched.
`javax.persistence.EntityTransaction`	`getTransaction()` Returns the resource-level transaction object, if User Transactions selected, otherwise proxy object returned for which only setRollbackOnly() is active.
`boolean`	`isOpen()` Determine whether the entity manager is open.
`void`	`joinTransaction()` NOT SUPPORTED.
`void`	`lock(Object entity, javax.persistence.LockModeType lockMode)` NOT SUPPORTED.
`<T> T`	`merge(T entity)` Merge the state of the given entity into the current persistence context.
`void`	`persist(Object entity)` Make an instance managed and persistent.
`void`	`refresh(Object entity)` Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
`void`	`remove(Object entity)` Remove the entity instance.
`void`	`setFlushMode(javax.persistence.FlushModeType flushMode)` Set the flush mode that applies to all objects contained in the persistence context.

- Method Detail
  - clear
```
void clear()
```
    Clear the persistence context, causing all managed entities to become detached. Changes made to entities that have not been flushed to the database will not be persisted.
    
    Throws:
    
    IllegalStateException - if this EntityManager has been closed.
  - close
```
void close()
```
    DO NOT CALL close() as the container will do this automatically. Close an application-managed entity manager. After the close method has been invoked, all methods on the EntityManager instance and any Query and TypedQuery objects obtained from it will throw the IllegalStateException except for getProperties, getTransaction, and isOpen (which will return false).
    
    Throws:
    
    IllegalStateException - if this EntityManager has been closed.
  - contains
```
boolean contains(Object entity)
```
    Check if the instance is a managed entity instance belonging to the current persistence context.
    
    Parameters:
    entity - the entity instance
    
    Returns:
    boolean indicating if entity is in persistence context
    
    Throws:
    
    IllegalArgumentException - if not an entity
    
    IllegalStateException - if this EntityManager has been closed.
  - createNamedQuery
```
javax.persistence.Query createNamedQuery(String name)
```
    Create an instance of Query for executing a named query (in the Java PersistenceUnitAdmin query language or in native SQL).
    
    Parameters:
    name - the name of a query defined in metadata
    
    Returns:
    the new query instance
    
    Throws:
    
    IllegalArgumentException - if a query has not been defined with the given name or if the query string is found to be invalid
  - flush
```
void flush()
```
    Synchronize the persistence context to the underlying database.
    
    Throws:
    
    PersistenceException - if the flush fails
    
    IllegalStateException - if this EntityManager has been closed.
  - getDelegate
```
Object getDelegate()
```
    Returns EntityManagerDelegate object which provides access to OrmLite DAOs. Return type of Object complies with PersistenceUnitAdmin API. Use cast to access the returned object as EntityManagerDelegate type.
    
    Returns:
    Object
    
    Throws:
    
    IllegalStateException - if this EntityManager has been closed.
  - getFlushMode
```
javax.persistence.FlushModeType getFlushMode()
```
    Get the flush mode that applies to all objects contained in the persistence context.
    
    Returns:
    flushMode
    
    Throws:
    
    IllegalStateException - if this EntityManager has been closed.
  - getReference
```
<T> T getReference(Class<T> entityClass,
                 Object primaryKey)
```
    Get an instance, whose state may be lazily fetched. If the requested instance does not exist in the database, the EntityNotFoundException is thrown when the instance state is first accessed. (The persistence provider runtime is permitted to throw the EntityNotFoundException when getReference is called.) The application should not expect that the instance state will be available upon detachment, unless it was accessed by the application while the entity manager was open.
    
    Type Parameters:
    T - the object type of the entity
    Parameters:
    entityClass - the class of the entity
    primaryKey - the primary key
    
    Returns:
    the found entity instance
    
    Throws:
    
    IllegalArgumentException - if the first argument does not denote an entity type or the second argument is not a valid type for that entity’s primary key or is null
    
    EntityNotFoundException - if the entity state cannot be accessed
    
    IllegalStateException - if this EntityManager has been closed.
  - getTransaction
```
javax.persistence.EntityTransaction getTransaction()
```
    Returns the resource-level transaction object, if User Transactions selected, otherwise proxy object returned for which only setRollbackOnly() is active. In User Transaction mode, the EntityTransaction instance may be used serially to begin and commit multiple transactions.
    
    Returns:
    EntityTransaction instance if in User Transaction mode, otherwise null
  - isOpen
```
boolean isOpen()
```
    Determine whether the entity manager is open.
    
    Returns:
    true until the entity manager has been closed
  - merge
```
<T> T merge(T entity)
```
    Merge the state of the given entity into the current persistence context.
    
    Type Parameters:
    T - the object type of the entity
    Parameters:
    entity - the entity instance
    
    Returns:
    the managed instance that the state was merged to
    
    Throws:
    
    IllegalArgumentException - if instance is not an entity or is a removed entity
    
    IllegalStateException - if this EntityManager has been closed.
  - persist
```
void persist(Object entity)
```
    Make an instance managed and persistent.
    
    Parameters:
    entity - the entity instance
    
    Throws:
    
    IllegalArgumentException - if the instance is not an entity
    
    IllegalStateException - if this EntityManager has been closed.
  - refresh
```
void refresh(Object entity)
```
    Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
    
    Parameters:
    entity - the entity instance
    
    Throws:
    
    IllegalArgumentException - if the instance is not an entity or the entity is not managed
    
    IllegalStateException - if this EntityManager has been closed.
  - remove
```
void remove(Object entity)
```
    Remove the entity instance.
    
    Parameters:
    entity - the entity instance
    
    Throws:
    
    IllegalArgumentException - if the instance is not an entity or is a detached entity
    
    IllegalStateException - if this EntityManager has been closed.
  - setFlushMode
```
void setFlushMode(javax.persistence.FlushModeType flushMode)
```
    Set the flush mode that applies to all objects contained in the persistence context.
    
    Parameters:
    flushMode - the flush mode
    
    Throws:
    
    IllegalStateException - if this EntityManager has been closed.
  - find
```
<T> T find(Class<T> entityClass,
         Object primaryKey)
```
    Find by primary key. Search for an entity of the specified class and primary key. If the entity instance is contained in the persistence context it is returned from there.
    
    Type Parameters:
    T - the object type of the entity
    Parameters:
    entityClass - the class of the entity
    primaryKey - the primary key
    
    Returns:
    the found entity instance or null if the entity does not exist
    
    Throws:
    
    IllegalArgumentException - if the first argument does not denote an entity type or the second argument is is not a valid type for that entity’s primary key or is null
    
    IllegalStateException - if this EntityManager has been closed.
  - joinTransaction
```
void joinTransaction()
```
    NOT SUPPORTED. Indicate to the entity manager that a JTA transaction is active. This method should be called on a JTA application managed entity manager that was created outside the scope of the active transaction or on an entity manager of type SynchronizationType.UNSYNCHRONIZED to associate it with the current JTA transaction.
    
    Throws:
    
    UnsupportedOperationException
  - lock
```
void lock(Object entity,
        javax.persistence.LockModeType lockMode)
```
    NOT SUPPORTED. Lock an entity instance that is contained in the persistence context with the specified lock mode type. If a pessimistic lock mode type is specified and the entity contains a version attribute, the persistence provider must also perform optimistic version checks when obtaining the database lock. If these checks fail, the OptimisticLockException will be thrown. If the lock mode type is pessimistic and the entity instance is found but cannot be locked: - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    
    Parameters:
    entity - the entity instance
    lockMode - the lock mode
    
    Throws:
    
    UnsupportedOperationException

Interface EntityManagerLite

Method Summary

Method Detail

clear

close

contains

createNamedQuery

flush

getDelegate

getFlushMode

getReference

getTransaction

isOpen

merge

persist

refresh

remove

setFlushMode

find

joinTransaction

lock