/// <summary>
/// Put a new, <seealso cref="DbEntityState.TRANSIENT"/> object into the cache.
/// </summary>
/// <param name="e"> the object to put into the cache </param>
public virtual void putTransient(DbEntity e)
{
CachedDbEntity cachedDbEntity = new CachedDbEntity();
cachedDbEntity.Entity = e;
cachedDbEntity.EntityState = TRANSIENT;
putInternal(cachedDbEntity);
}
/// <summary>
/// Put a <seealso cref="DbEntityState.MERGED"/> object into the cache.
/// </summary>
/// <param name="e"> the object to put into the cache </param>
public virtual void putMerged(DbEntity e)
{
CachedDbEntity cachedDbEntity = new CachedDbEntity();
cachedDbEntity.Entity = e;
cachedDbEntity.EntityState = MERGED;
cachedDbEntity.determineEntityReferences();
// no copy required
putInternal(cachedDbEntity);
}
/// <summary>
/// Put a <seealso cref="DbEntityState.PERSISTENT"/> object into the cache.
/// </summary>
/// <param name="e"> the object to put into the cache </param>
public virtual void putPersistent(DbEntity e)
{
CachedDbEntity cachedDbEntity = new CachedDbEntity();
cachedDbEntity.Entity = e;
cachedDbEntity.EntityState = PERSISTENT;
cachedDbEntity.determineEntityReferences();
cachedDbEntity.makeCopy();
putInternal(cachedDbEntity);
}
public virtual void undoDelete(DbEntity dbEntity)
{
CachedDbEntity cachedEntity = getCachedEntity(dbEntity);
if (cachedEntity.EntityState == DbEntityState.DELETED_TRANSIENT)
{
cachedEntity.EntityState = DbEntityState.TRANSIENT;
}
else
{
cachedEntity.EntityState = DbEntityState.MERGED;
}
}
/// <summary>
/// Allows checking whether the provided entity is present in the cache
/// and is <seealso cref="DbEntityState.TRANSIENT"/>.
/// </summary>
/// <param name="dbEntity"> the entity to check </param>
/// <returns> true if the provided entity is present in the cache and is
/// <seealso cref="DbEntityState.TRANSIENT"/>. </returns>
public virtual bool isTransient(DbEntity dbEntity)
{
CachedDbEntity cachedDbEntity = getCachedEntity(dbEntity);
if (cachedDbEntity == null)
{
return(false);
}
else
{
return(cachedDbEntity.EntityState == TRANSIENT);
}
}
/// <summary>
/// Allows checking whether the provided entity is present in the cache
/// and is marked to be deleted.
/// </summary>
/// <param name="dbEntity"> the entity to check </param>
/// <returns> true if the provided entity is present in the cache and is
/// marked to be deleted </returns>
public virtual bool isDeleted(DbEntity dbEntity)
{
CachedDbEntity cachedDbEntity = getCachedEntity(dbEntity);
if (cachedDbEntity == null)
{
return(false);
}
else
{
return(cachedDbEntity.EntityState == DELETED_MERGED || cachedDbEntity.EntityState == DELETED_PERSISTENT || cachedDbEntity.EntityState == DELETED_TRANSIENT);
}
}
/// <summary>
/// Allows checking whether the provided entity is present in the cache
/// and is <seealso cref="DbEntityState.PERSISTENT"/>.
/// </summary>
/// <param name="dbEntity"> the entity to check </param>
/// <returns> true if the provided entity is present in the cache and is
/// <seealso cref="DbEntityState.PERSISTENT"/>. </returns>
public virtual bool isPersistent(DbEntity dbEntity)
{
CachedDbEntity cachedDbEntity = getCachedEntity(dbEntity);
if (cachedDbEntity == null)
{
return(false);
}
else
{
return(cachedDbEntity.EntityState == PERSISTENT);
}
}
/// <summary>
/// get an object from the cache
/// </summary>
/// <param name="type"> the type of the object </param>
/// <param name="id"> the id of the object </param>
/// <returns> the object or 'null' if the object is not in the cache </returns>
/// <exception cref="ProcessEngineException"> if an object for the given id can be found but is of the wrong type. </exception>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public <T extends org.camunda.bpm.engine.impl.db.DbEntity> T get(Class<T> type, String id)
public virtual T get <T>(Type type, string id) where T : org.camunda.bpm.engine.impl.db.DbEntity
{
type = typeof(T);
Type cacheKey = cacheKeyMapping.getEntityCacheKey(type);
CachedDbEntity cachedDbEntity = getCachedEntity(cacheKey, id);
if (cachedDbEntity != null)
{
DbEntity dbEntity = cachedDbEntity.Entity;
try
{
return((T)dbEntity);
}
catch (System.InvalidCastException e)
{
throw LOG.entityCacheLookupException(type, id, dbEntity.GetType(), e);
}
}
else
{
return(null);
}
}
/// <param name="cachedDbEntity"> </param>
public virtual void remove(CachedDbEntity cachedDbEntity)
{
remove(cachedDbEntity.Entity);
}
protected internal virtual void putInternal(CachedDbEntity entityToAdd)
{
Type type = entityToAdd.Entity.GetType();
Type cacheKey = cacheKeyMapping.getEntityCacheKey(type);
IDictionary <string, CachedDbEntity> map = cachedEntites[cacheKey];
if (map == null)
{
map = new Dictionary <string, CachedDbEntity>();
cachedEntites[cacheKey] = map;
}
// check whether this object is already present in the cache
CachedDbEntity existingCachedEntity = map[entityToAdd.Entity.Id];
if (existingCachedEntity == null)
{
// no such entity exists -> put it into the cache
map[entityToAdd.Entity.Id] = entityToAdd;
}
else
{
// the same entity is already cached
switch (entityToAdd.EntityState)
{
case TRANSIENT:
// cannot put TRANSIENT entity if entity with same id already exists in cache.
if (existingCachedEntity.EntityState == TRANSIENT)
{
throw LOG.entityCacheDuplicateEntryException("TRANSIENT", entityToAdd.Entity.Id, entityToAdd.Entity.GetType(), existingCachedEntity.EntityState);
}
else
{
throw LOG.alreadyMarkedEntityInEntityCacheException(entityToAdd.Entity.Id, entityToAdd.Entity.GetType(), existingCachedEntity.EntityState);
}
case PERSISTENT:
if (existingCachedEntity.EntityState == PERSISTENT)
{
// use new entity state, replacing the existing one.
map[entityToAdd.Entity.Id] = entityToAdd;
break;
}
if (existingCachedEntity.EntityState == DELETED_PERSISTENT || existingCachedEntity.EntityState == DELETED_MERGED)
{
// ignore put -> this is already marked to be deleted
break;
}
// otherwise fail:
throw LOG.entityCacheDuplicateEntryException("PERSISTENT", entityToAdd.Entity.Id, entityToAdd.Entity.GetType(), existingCachedEntity.EntityState);
case MERGED:
if (existingCachedEntity.EntityState == PERSISTENT || existingCachedEntity.EntityState == MERGED)
{
// use new entity state, replacing the existing one.
map[entityToAdd.Entity.Id] = entityToAdd;
break;
}
if (existingCachedEntity.EntityState == DELETED_PERSISTENT || existingCachedEntity.EntityState == DELETED_MERGED)
{
// ignore put -> this is already marked to be deleted
break;
}
// otherwise fail:
throw LOG.entityCacheDuplicateEntryException("MERGED", entityToAdd.Entity.Id, entityToAdd.Entity.GetType(), existingCachedEntity.EntityState);
default:
// deletes are always added
map[entityToAdd.Entity.Id] = entityToAdd;
break;
}
}
}